# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import sys import unittest import numpy as np import scipy import scipy.fft import paddle DEVICES = [] if paddle.is_compiled_with_xpu(): DEVICES.append(paddle.XPUPlace(0)) TEST_CASE_NAME = 'suffix' RTOL = { 'float32': 1e-3, 'complex64': 1e-3, } ATOL = {'float32': 1e-3, 'complex64': 1e-3} def rand_x( dims=1, dtype='float32', min_dim_len=9, max_dim_len=12, complex=False ): shape = [np.random.randint(min_dim_len, max_dim_len) for i in range(dims)] if complex: return np.random.randn(*shape).astype(dtype) + 1.0j * np.random.randn( *shape ).astype(dtype) else: return np.random.randn(*shape).astype(dtype) def place(devices, key='place'): def decorate(cls): module = sys.modules[cls.__module__].__dict__ raw_classes = { k: v for k, v in module.items() if k.startswith(cls.__name__) } for raw_name, raw_cls in raw_classes.items(): for d in devices: test_cls = dict(raw_cls.__dict__) test_cls.update({key: d}) new_name = raw_name + '.' + d.__class__.__name__ module[new_name] = type(new_name, (raw_cls,), test_cls) del module[raw_name] return cls return decorate def parameterize(fields, values=None): fields = [fields] if isinstance(fields, str) else fields params = [dict(zip(fields, vals)) for vals in values] def decorate(cls): test_cls_module = sys.modules[cls.__module__].__dict__ for k, v in enumerate(params): test_cls = dict(cls.__dict__) test_cls.update(v) name = cls.__name__ + str(k) name = name + '.' + v.get('suffix') if v.get('suffix') else name test_cls_module[name] = type(name, (cls,), test_cls) for m in list(cls.__dict__): if m.startswith("test"): delattr(cls, m) return cls return decorate @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ('test_x_float32', rand_x(5, np.float32), None, -1, 'backward'), ('test_x_complex', rand_x(5, complex=True), None, -1, 'backward'), ( 'test_n_grater_input_length', rand_x(5, max_dim_len=10), 11, -1, 'backward', ), ('test_axis_not_last', rand_x(5), None, 3, 'backward'), ('test_norm_forward', rand_x(5), None, 3, 'forward'), ('test_norm_ortho', rand_x(5), None, 3, 'ortho'), ], ) class TestFft(unittest.TestCase): def test_fft(self): """Test fft with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fft(self.x, self.n, self.axis, self.norm), paddle.fft.fft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x_float32', rand_x(5, np.float32), None, -1, 'backward'), ('test_x_complex64', rand_x(5, complex=True), None, -1, 'backward'), # ( # 'test_n_grater_input_length', # rand_x(5, max_dim_len=10), # 11, # -1, # 'backward', # ), # ('test_axis_not_last', rand_x(5), None, 3, 'backward'), # ('test_norm_forward', rand_x(5), None, 3, 'forward'), # ('test_norm_ortho', rand_x(5), None, 3, 'ortho'), ], ) class TestIfft(unittest.TestCase): def test_fft(self): """Test ifft with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ifft(self.x, self.n, self.axis, self.norm), paddle.fft.ifft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ('test_n_negative', rand_x(2), -1, -1, 'backward', ValueError), ('test_n_zero', rand_x(2), 0, -1, 'backward', ValueError), ('test_axis_out_of_range', rand_x(1), None, 10, 'backward', ValueError), ( 'test_axis_with_array', rand_x(1), None, (0, 1), 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', rand_x(2), None, -1, 'random', ValueError, ), ], ) class TestFftException(unittest.TestCase): def test_fft(self): """Test fft with boundary condition Test case include: - n out of range - axis out of range - axis type error - norm out of range """ with self.assertRaises(self.expect_exception): paddle.fft.fft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ('test_x_float32', rand_x(5), None, (0, 1), 'backward'), ( 'test_x_complex64', rand_x(5, complex=True), None, (0, 1), 'backward', ), ('test_axis_random', rand_x(5), None, (1, 2), 'backward'), ('test_norm_forward', rand_x(5), None, (0, 1), 'forward'), ('test_norm_ortho', rand_x(5), None, (0, 1), 'ortho'), ], ) class TestFft2(unittest.TestCase): def test_fft2(self): """Test fft2 with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fft2(self.x, self.n, self.axis, self.norm), paddle.fft.fft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_x_complex_input', rand_x(2, complex=True), None, (0, 1), None, ValueError, ), ('test_x_1dim_tensor', rand_x(1), None, (0, 1), None, ValueError), ('test_n_negative', rand_x(2), -1, (0, 1), 'backward', ValueError), ( 'test_n_len_not_equal_axis', rand_x(5, max_dim_len=10), 11, (0, 1), 'backward', ValueError, ), ('test_n_zero', rand_x(2), (0, 0), (0, 1), 'backward', ValueError), ( 'test_axis_out_of_range', rand_x(2), None, (0, 1, 2), 'backward', ValueError, ), ( 'test_axis_with_array', rand_x(1), None, (0, 1), 'backward', ValueError, ), ( 'test_axis_not_sequence', rand_x(5), None, -10, 'backward', ValueError, ), ('test_norm_not_enum', rand_x(2), None, -1, 'random', ValueError), ], ) class TestFft2Exception(unittest.TestCase): def test_fft2(self): """Test fft2 with boundary condition Test case include: - input type error - input dim error - n out of range - axis out of range - axis type error - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.fft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ('test_x_float32', rand_x(5, np.float32), None, (0, 1, 2), 'backward'), ('test_x_complex64', rand_x(5, complex=True), None, (1, 2), 'backward'), ('test_axis_not_default', rand_x(5), None, (0, 1, 2), 'backward'), ('test_norm_forward', rand_x(5), None, (0, 1), 'forward'), ('test_norm_ortho', rand_x(5), None, (0, 1), 'ortho'), ], ) class TestFftn(unittest.TestCase): def test_fftn(self): """Test fftn with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fftn(self.x, self.n, self.axis, self.norm), paddle.fft.fftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x_float32', rand_x(5, np.float32), None, (1, 2), 'backward'), ('test_x_complex64', rand_x(5, complex=True), None, (1, 2), 'backward'), # ('test_axis_not_default', rand_x(5), None, (1, 2), 'backward'), # ('test_norm_forward', rand_x(5), None, (1, 2), 'forward'), # ('test_norm_ortho', rand_x(5), None, (1, 2), 'ortho'), ( 'test_xpu_0size_pad', ( np.random.randn(50, 8, 0, 14, 14) + 1j * np.random.randn(50, 8, 0, 14, 14) ).astype(np.complex64), (39, 14, 14), None, 'backward', ), ], ) class TestIFftn(unittest.TestCase): def test_ifftn(self): """Test ifftn with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ifftn(self.x, self.n, self.axis, self.norm), paddle.fft.ifftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ( 'test_x_complex64', ( np.random.randn(9, 16, 16) + 1j * np.random.randn(9, 16, 16) ).astype(np.complex64), None, -1, "backward", ), ( 'test_axis_not_last', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, 1, "backward", ), ( 'test_norm_forward', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, 1, "forward", ), ( 'test_norm_ortho', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, -1, "ortho", ), ], ) class TestHfft(unittest.TestCase): def test_hfft(self): """Test hfft with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.hfft(self.x, self.n, self.axis, self.norm), paddle.fft.hfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=1e-3, atol=1e-3, ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ( 'test_x_complex64', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, -1, "backward", ), ( 'test_axis_not_last', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, -1, "backward", ), ( 'test_norm_forward', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, -1, "forward", ), ( 'test_norm_ortho', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, -1, "ortho", ), ], ) class TestIrfft(unittest.TestCase): def test_irfft(self): """Test irfft with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.irfft(self.x, self.n, self.axis, self.norm), paddle.fft.irfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=1e-3, atol=1e-3, ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ( 'test_x_complex64', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "backward", ), ( 'test_axis_not_last', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "backward", ), ( 'test_norm_forward', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "forward", ), ( 'test_norm_ortho', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "ortho", ), ], ) class TestIrfftn(unittest.TestCase): def test_irfftn(self): """Test irfftn with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.irfftn(self.x, self.n, self.axis, self.norm), paddle.fft.irfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=1e-3, atol=1e-3, ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ( 'test_x_complex128', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "backward", ), ( 'test_axis_not_last', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "backward", ), ( 'test_norm_forward', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "forward", ), ( 'test_norm_ortho', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (1, 2), "ortho", ), ], ) class TestHfftn(unittest.TestCase): def test_hfftn(self): """Test hfftn with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.hfftn(self.x, self.n, self.axis, self.norm), paddle.fft.hfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=1e-3, atol=1e-3, ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 's', 'axis', 'norm'), [ ( 'test_x_complex128', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "backward", ), ( 'test_axis_not_last', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "backward", ), ( 'test_norm_forward', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "forward", ), ( 'test_norm_ortho', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "ortho", ), ], ) class TestHfft2(unittest.TestCase): def test_hfft2(self): """Test hfft2 with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.hfft2(self.x, self.s, self.axis, self.norm), paddle.fft.hfft2( paddle.to_tensor(self.x), self.s, self.axis, self.norm ), rtol=1e-3, atol=1e-3, ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 's', 'axis', 'norm'), [ ( 'test_x_complex128', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "backward", ), ( 'test_axis_not_last', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "backward", ), ( 'test_norm_forward', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "forward", ), ( 'test_norm_ortho', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), None, (-2, -1), "ortho", ), ], ) class TestIrfft2(unittest.TestCase): def test_irfft2(self): """Test irfft2 with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.irfft2(self.x, self.s, self.axis, self.norm), paddle.fft.irfft2( paddle.to_tensor(self.x), self.s, self.axis, self.norm ), rtol=1e-3, atol=1e-3, ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_bool_input', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.bool_), None, -1, 'backward', RuntimeError, ), ( 'test_n_negative', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), -1, -1, 'backward', ValueError, ), ( 'test_n_zero', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), 0, -1, 'backward', ValueError, ), ( 'test_n_type', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (1, 2, 3), -1, 'backward', ValueError, ), ( 'test_axis_out_of_range', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, 10, 'backward', ValueError, ), ( 'test_axis_with_array', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, (0, 1), 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), None, -1, 'random', ValueError, ), ], ) class TestHfftException(unittest.TestCase): def test_hfft(self): """Test hfft with boundary condition Test case include: Test case include: - n out of range - n type error - axis out of range - axis type error - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.hfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_n_negative', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), -1, -1, 'backward', ValueError, ), ( 'test_n_zero', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), 0, -1, 'backward', ValueError, ), ( 'test_n_type', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (1, 2), -1, 'backward', ValueError, ), ( 'test_axis_out_of_range', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, 10, 'backward', ValueError, ), ( 'test_axis_with_array', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, (0, 1), 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), None, None, 'random', ValueError, ), ], ) class TestIrfftException(unittest.TestCase): def test_irfft(self): """ Test irfft with boundary condition Test case include: - n out of range - n type error - axis type error - axis out of range - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.irfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_bool_input', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.bool_), None, (-2, -1), 'backward', RuntimeError, ), ( 'test_n_negative', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (-1, -2), (-2, -1), 'backward', ValueError, ), ( 'test_n_zero', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (0, 0), (-2, -1), 'backward', ValueError, ), ( 'test_n_type', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), 9, None, 'backward', ValueError, ), ( 'test_n_axis_dim', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (1, 2), (-1), 'backward', ValueError, ), ( 'test_axis_out_of_range', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, (1, 2), 'backward', ValueError, ), ( 'test_axis_type', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, -1, 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), None, -1, 'random', ValueError, ), ], ) class TestHfft2Exception(unittest.TestCase): def test_hfft2(self): """ Test hfft2 with boundary condition Test case include: - input type error - n type error - n out of range - axis out of range - the dimensions of n and axis are different - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.hfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_n_negative', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (-1, -2), (-2, -1), 'backward', ValueError, ), ( 'test_n_zero', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (0, 0), (-2, -1), 'backward', ValueError, ), ( 'test_n_type', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), 3, -1, 'backward', ValueError, ), ( 'test_n_axis_dim', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (1, 2), (-3, -2, -1), 'backward', ValueError, ), ( 'test_axis_out_of_range', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, (1, 2), 'backward', ValueError, ), ( 'test_axis_type', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, 1, 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), None, None, 'random', ValueError, ), ], ) class TestIrfft2Exception(unittest.TestCase): def test_irfft2(self): """ Test irfft2 with boundary condition Test case include: - input type error - n type error - n out of range - axis out of range - the dimensions of n and axis are different - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.irfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_bool_input', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.bool_), None, (-2, -1), 'backward', RuntimeError, ), ( 'test_n_negative', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (-1, -2), (-2, -1), 'backward', ValueError, ), ( 'test_n_zero', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (0, 0), (-2, -1), 'backward', ValueError, ), ( 'test_n_type', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), 3, -1, 'backward', ValueError, ), ( 'test_n_axis_dim', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (1, 2), (-3, -2, -1), 'backward', ValueError, ), ( 'test_axis_out_of_range', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, (10, 20), 'backward', ValueError, ), ( 'test_axis_type', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, 1, 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), None, None, 'random', ValueError, ), ], ) class TestHfftnException(unittest.TestCase): def test_hfftn(self): """Test hfftn with boundary condition Test case include: - input type error - n type error - n out of range - axis out of range - the dimensions of n and axis are different - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.hfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_n_negative', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (-1, -2), (-2, -1), 'backward', ValueError, ), ( 'test_n_zero', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16).astype(np.complex64) ), (0, 0), (-2, -1), 'backward', ValueError, ), ( 'test_n_type', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), 3, -1, 'backward', ValueError, ), ( 'test_n_axis_dim', ( np.random.randn(8, 16, 16) + 1j * np.random.randn(8, 16, 16) ).astype(np.complex64), (1, 2), (-3, -2, -1), 'backward', ValueError, ), ( 'test_axis_out_of_range', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, (10, 20), 'backward', ValueError, ), ( 'test_axis_type', (np.random.randn(16) + 1j * np.random.randn(16)).astype( np.complex64 ), None, 1, 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', (np.random.randn(16, 16) + 1j * np.random.randn(16, 16)).astype( np.complex64 ), None, None, 'random', ValueError, ), ], ) class TestIrfftnException(unittest.TestCase): def test_irfftn(self): """Test irfftn with boundary condition Test case include: - n out of range - n type error - axis out of range - norm out of range - the dimensions of n and axis are different """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.irfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ('test_x_float32', rand_x(5, np.float32), None, -1, 'backward'), ( 'test_n_grater_than_input_length', rand_x(5, max_dim_len=16), 11, -1, 'backward', ), ( 'test_n_smaller_than_input_length', rand_x(5, min_dim_len=9), 9, -1, 'backward', ), ('test_axis_not_last', rand_x(5), None, 3, 'backward'), ('test_norm_forward', rand_x(5), None, 3, 'forward'), ('test_norm_ortho', rand_x(5), None, 3, 'ortho'), ], ) class TestRfft(unittest.TestCase): def test_rfft(self): """Test rfft with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.rfft(self.x, self.n, self.axis, self.norm), paddle.fft.rfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ('test_n_negative', rand_x(2), -1, -1, 'backward', ValueError), ('test_n_zero', rand_x(2), 0, -1, 'backward', ValueError), ('test_axis_out_of_range', rand_x(1), None, 10, 'backward', ValueError), ( 'test_axis_with_array', rand_x(1), None, (0, 1), 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', rand_x(2), None, -1, 'random', ValueError, ), ], ) class TestRfftException(unittest.TestCase): def test_rfft(self): """Test rfft with boundary condition Test case include: - n out of range - axis out of range - axis type error - norm out of range - the dimensions of n and axis are different """ with self.assertRaises(self.expect_exception): paddle.fft.rfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ('test_x_float32', rand_x(5), None, (0, 1), 'backward'), ( 'test_n_grater_input_length', rand_x(5, max_dim_len=16), (12, 12), (0, 1), 'backward', ), ( 'test_n_smaller_than_input_length', rand_x(5, min_dim_len=9), (9, 9), (0, 1), 'backward', ), ('test_axis_random', rand_x(5), None, (1, 2), 'backward'), ('test_norm_forward', rand_x(5), None, (0, 1), 'forward'), ('test_norm_ortho', rand_x(5), None, (0, 1), 'ortho'), ], ) class TestRfft2(unittest.TestCase): def test_rfft2(self): """Test rfft2 with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.rfft2(self.x, self.n, self.axis, self.norm), paddle.fft.rfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_x_complex_input', rand_x(2, complex=True), None, (0, 1), 'backward', RuntimeError, ), ('test_x_1dim_tensor', rand_x(1), None, (0, 1), 'backward', ValueError), ('test_n_negative', rand_x(2), -1, (0, 1), 'backward', ValueError), ('test_n_zero', rand_x(2), 0, (0, 1), 'backward', ValueError), ( 'test_axis_out_of_range', rand_x(2), None, (0, 1, 2), 'backward', ValueError, ), ( 'test_axis_with_array', rand_x(1), None, (0, 1), 'backward', ValueError, ), ( 'test_axis_not_sequence', rand_x(5), None, -10, 'backward', ValueError, ), ('test_norm_not_enum', rand_x(2), None, -1, 'random', ValueError), ], ) class TestRfft2Exception(unittest.TestCase): def test_rfft2(self): """Test rfft2 with boundary condition Test case include: - input type error - input dim error - n out of range - axis out of range - norm out of range - the dimensions of n and axis are different """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.rfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ ('test_x_float32', rand_x(5, np.float32), None, (1, 2), 'backward'), ( 'test_n_grater_input_length', rand_x(5, max_dim_len=16), (12, 12), (1, 2), 'backward', ), ( 'test_n_smaller_input_length', rand_x(5, min_dim_len=9), (9, 9), (1, 2), 'backward', ), ('test_axis_not_default', rand_x(5), None, (1, 2), 'backward'), ('test_norm_forward', rand_x(5), None, (1, 2), 'forward'), ('test_norm_ortho', rand_x(5), None, (1, 2), 'ortho'), ], ) class TestRfftn(unittest.TestCase): def test_rfftn(self): """Test rfftn with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.rfftn(self.x, self.n, self.axis, self.norm), paddle.fft.rfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_x_complex', rand_x(4, complex=True), None, (1, 2), 'backward', RuntimeError, ), ( 'test_n_negative', rand_x(4), (-1, -1), (1, 2), 'backward', ValueError, ), ('test_n_not_sequence', rand_x(4), -1, None, 'backward', ValueError), ('test_n_zero', rand_x(4), 0, None, 'backward', ValueError), ( 'test_axis_out_of_range', rand_x(1), None, [0, 1], 'backward', ValueError, ), ('test_norm_not_in_enum', rand_x(2), None, -1, 'random', ValueError), ], ) class TestRfftnException(unittest.TestCase): def test_rfftn(self): """Test rfftn with boundary condition Test case include: - n out of range - axis out of range - norm out of range - the dimensions of n and axis are different """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.rfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x_float32', rand_x(5, np.float32), None, -1, 'backward'), # ( # 'test_n_grater_than_input_length', # rand_x(5, max_dim_len=16), # 11, # -1, # 'backward', # ), # ( # 'test_n_smaller_than_input_length', # rand_x(5, min_dim_len=10), # 9, # -1, # 'backward', # ), # ('test_axis_not_last', rand_x(5), None, 3, 'backward'), # ('test_norm_forward', rand_x(5), None, 3, 'forward'), # ('test_norm_ortho', rand_x(5), None, 3, 'ortho'), ], ) class TestIhfft(unittest.TestCase): def test_ihfft(self): """Test ihfft with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ihfft(self.x, self.n, self.axis, self.norm), paddle.fft.ihfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ('test_n_negative', rand_x(2), -1, -1, 'backward', ValueError), ('test_n_zero', rand_x(2), 0, -1, 'backward', ValueError), ('test_axis_out_of_range', rand_x(1), None, 10, 'backward', ValueError), ( 'test_axis_with_array', rand_x(1), None, (0, 1), 'backward', ValueError, ), ( 'test_norm_not_in_enum_value', rand_x(2), None, -1, 'random', ValueError, ), ], ) class TestIhfftException(unittest.TestCase): def test_ihfft(self): """Test ihfft with boundary condition Test case include: - axis type error - axis out of range - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.ihfft( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x_float32', rand_x(5), None, (0, 1), 'backward'), # ( # 'test_n_grater_input_length', # rand_x(5, max_dim_len=12), # (11, 11), # (0, 1), # 'backward', # ), # ( # 'test_n_smaller_than_input_length', # rand_x(5, min_dim_len=9), # (9, 9), # (0, 1), # 'backward', # ), # ('test_axis_random', rand_x(5), None, (1, 2), 'backward'), # ('test_norm_forward', rand_x(5), None, (0, 1), 'forward'), # ('test_norm_ortho', rand_x(5), None, (0, 1), 'ortho'), ], ) class TestIhfft2(unittest.TestCase): def test_ihfft2(self): """Test ihfft2 with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ihfft2(self.x, self.n, self.axis, self.norm), paddle.fft.ihfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_x_complex_input', rand_x(2, complex=True), None, (0, 1), None, ValueError, ), ('test_x_1dim_tensor', rand_x(1), None, (0, 1), None, ValueError), ('test_n_negative', rand_x(2), -1, (0, 1), 'backward', ValueError), ( 'test_n_len_not_equal_axis', rand_x(5, max_dim_len=16), 11, (0, 1), 'backward', ValueError, ), ( 'test_axis_out_of_range', rand_x(2), None, (0, 1, 2), 'backward', ValueError, ), ( 'test_axis_with_array', rand_x(1), None, (0, 1), 'backward', ValueError, ), ( 'test_axis_not_sequence', rand_x(5), None, -10, 'backward', ValueError, ), ('test_norm_not_enum', rand_x(2), None, -1, 'random', ValueError), ], ) class TestIhfft2Exception(unittest.TestCase): def test_ihfft2(self): """Test ihfft2 with boundary condition Test case include: - input type error - input dim error - n out of range - axis type error - axis out of range - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.ihfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x_float32', rand_x(5, np.float32), None, (1, 2), 'backward'), # ('test_axis_not_default', rand_x(5), None, (1, 2), 'backward'), # ('test_norm_forward', rand_x(5), None, (1, 2), 'forward'), # ('test_norm_ortho', rand_x(5), None, (1, 2), 'ortho'), ], ) class TestIhfftn(unittest.TestCase): def test_ihfftn(self): """Test ihfftn with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ihfftn(self.x, self.n, self.axis, self.norm), paddle.fft.ihfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm', 'expect_exception'), [ ( 'test_x_complex', rand_x(4, complex=True), None, None, 'backward', RuntimeError, ), ('test_n_negative', rand_x(4), -1, None, 'backward', ValueError), ('test_n_zero', rand_x(4), 0, None, 'backward', ValueError), ( 'test_axis_out_of_range', rand_x(1), None, [0, 1], 'backward', ValueError, ), ('test_norm_not_in_enum', rand_x(2), None, -1, 'random', ValueError), ], ) class TestIhfftnException(unittest.TestCase): def test_ihfftn(self): """Test ihfftn with boundary condition Test case include: - input type error - n out of range - axis out of range - norm out of range """ with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.ihfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'n', 'd', 'dtype'), [ ('test_without_d', 20, 1, 'float32'), ('test_with_d', 20, 0.5, 'float32'), ], ) class TestFftFreq(unittest.TestCase): def test_fftfreq(self): """Test fftfreq with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fftfreq(self.n, self.d).astype(self.dtype), paddle.fft.fftfreq(self.n, self.d, self.dtype).numpy(), rtol=RTOL.get(str(self.dtype)), atol=ATOL.get(str(self.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'n', 'd', 'dtype', 'expect_exception'), [ ('test_with_0_0', 0, 0, 'float32', ValueError), ('test_with_n_0', 20, 0, 'float32', ValueError), ('test_with_0_d', 0, 20, 'float32', ValueError), ], ) class TestFftFreqException(unittest.TestCase): def test_fftfreq2(self): """Test fftfreq with d = 0""" with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.fftfreq(self.n, self.d, self.dtype) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'n', 'd', 'dtype'), [ ('test_without_d', 20, 1, 'float32'), ('test_with_d', 20, 0.5, 'float32'), ], ) class TestRfftFreq(unittest.TestCase): def test_rfftfreq(self): """Test rfftfreq with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.rfftfreq(self.n, self.d).astype(self.dtype), paddle.fft.rfftfreq(self.n, self.d, self.dtype).numpy(), rtol=RTOL.get(str(self.dtype)), atol=ATOL.get(str(self.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'n', 'd', 'dtype', 'expect_exception'), [ ('test_with_0_0', 0, 0, 'float32', ValueError), ('test_with_n_0', 20, 0, 'float32', ValueError), ('test_with_0_d', 0, 20, 'float32', ValueError), ], ) class TestRfftFreqException(unittest.TestCase): def test_rfftfreq2(self): """Test fftfreq with d = 0""" with ( paddle.base.dygraph.guard(self.place), self.assertRaises(self.expect_exception), ): paddle.fft.rfftfreq(self.n, self.d, self.dtype) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'axes', 'dtype'), [ ('test_1d', np.random.randn(10).astype(np.float32), (0,), 'float32'), ( 'test_2d', np.random.randn(10, 10).astype(np.float32), (0, 1), 'float32', ), ( 'test_2d_with_all_axes', np.random.randn(10, 10).astype(np.float32), None, 'float32', ), ( 'test_2d_odd_with_all_axes', (np.random.randn(9, 9) + 1j * np.random.randn(9, 9)).astype( np.complex64 ), None, 'complex64', ), ], ) class TestFftShift(unittest.TestCase): def test_fftshift(self): """Test fftshift with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fftshift(self.x, self.axes), paddle.fft.fftshift( paddle.to_tensor(self.x), self.axes ).numpy(), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'axes'), [ ('test_1d', np.random.randn(10).astype(np.float32), (0,), 'float32'), ( 'test_2d', np.random.randn(10, 10).astype(np.float32), (0, 1), 'float32', ), ( 'test_2d_with_all_axes', np.random.randn(10, 10).astype(np.float32), None, 'float32', ), ( 'test_2d_odd_with_all_axes', (np.random.randn(5, 5) + 1j * np.random.randn(5, 5)).astype( np.complex64 ), None, 'complex64', ), ], ) class TestIfftShift(unittest.TestCase): def test_ifftshift(self): """Test ifftshift with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ifftshift(self.x, self.axes), paddle.fft.ifftshift( paddle.to_tensor(self.x), self.axes ).numpy(), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'axes', 'dtype'), [ # ('test_1d', np.random.randn(0).astype(np.float32), (0,), 'float32'), # ( # 'test_2d_odd_with_all_axes', # (np.random.randn(5, 0) + 1j * np.random.randn(5, 0)).astype( # np.complex64 # ), # None, # 'complex64', # ), ], ) class TestFftShift_ZeroSize(unittest.TestCase): def test_fftshift(self): """Test fftshift with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fftshift(self.x, self.axes), paddle.fft.fftshift( paddle.to_tensor(self.x), self.axes ).numpy(), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.fftshift(x, self.axes) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'axes'), [ # ('test_1d', np.random.randn(0).astype(np.float32), (0,), 'float32'), # ( # 'test_2d_odd_with_all_axes', # (np.random.randn(5, 0) + 1j * np.random.randn(5, 0)).astype( # np.complex64 # ), # None, # 'complex64', # ), ], ) class TestIfftShift_ZeroSize(unittest.TestCase): def test_ifftshift(self): """Test ifftshift with norm condition""" with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ifftshift(self.x, self.axes), paddle.fft.ifftshift( paddle.to_tensor(self.x), self.axes ).numpy(), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.ifftshift(x, self.axes) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(3, 3, 0, 2).astype(np.float32), None, (0, 1), 'backward'), ], ) class TestFft2_ZeroSize(unittest.TestCase): def test_fft2(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fft2(self.x, self.n, self.axis, self.norm), paddle.fft.fft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.fft2(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(4, 0, 6).astype(np.float32), (2, 4), None, 'backward'), ], ) class TestFftn_ZeroSize(unittest.TestCase): def test_fftn(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.fftn(self.x, self.n, self.axis, self.norm), paddle.fft.fftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.fftn(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(3, 3, 0, 2).astype(np.float32), (1, 2), (0, 1), 'backward'), ], ) class TestIfft2_ZeroSize(unittest.TestCase): def test_ifft2(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ifft2(self.x, self.n, self.axis, self.norm), paddle.fft.ifft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.ifft2(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(4, 0, 6).astype(np.float32), (2, 4), None, 'backward'), ], ) class TestIfftn_ZeroSize(unittest.TestCase): def test_ifftn(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ifftn(self.x, self.n, self.axis, self.norm), paddle.fft.ifftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.ifftn(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(3, 3, 0, 2).astype(np.float32), None, (0, 1), 'backward'), ], ) class TestIhfft2_ZeroSize(unittest.TestCase): def test_ihfft2(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ihfft2(self.x, self.n, self.axis, self.norm), paddle.fft.ihfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.ihfft2(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(4, 0, 6).astype(np.float32), (2, 4), None, 'backward'), ], ) class TestIhfftn_ZeroSize(unittest.TestCase): def test_ihfftn(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.ihfftn(self.x, self.n, self.axis, self.norm), paddle.fft.ihfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.ihfftn(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(3, 3, 0, 2).astype(np.float32), None, (0, 1), 'backward'), ], ) class TestRfft2_ZeroSize(unittest.TestCase): def test_rfft2(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.rfft2(self.x, self.n, self.axis, self.norm), paddle.fft.rfft2( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.rfft2(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) @place(DEVICES) @parameterize( (TEST_CASE_NAME, 'x', 'n', 'axis', 'norm'), [ # ('test_x', np.random.randn(4, 0, 6).astype(np.float32), (2, 4), None, 'backward'), ], ) class TestRfftn_ZeroSize(unittest.TestCase): def test_rfftn(self): with paddle.base.dygraph.guard(self.place): np.testing.assert_allclose( scipy.fft.rfftn(self.x, self.n, self.axis, self.norm), paddle.fft.rfftn( paddle.to_tensor(self.x), self.n, self.axis, self.norm ), rtol=RTOL.get(str(self.x.dtype)), atol=ATOL.get(str(self.x.dtype)), ) def test_grad_shape(self): with paddle.base.dygraph.guard(self.place): x = paddle.to_tensor(self.x, stop_gradient=False) y = paddle.fft.rfftn(x, self.n, self.axis, self.norm) loss = paddle.sum(y) loss.backward() np.testing.assert_equal( x.grad.shape, self.x.shape, "Grad shape mismatch" ) if __name__ == '__main__': unittest.main()