Example #1
0
 def test_ifft2(self):
     x = random((30, 20)) + 1j * random((30, 20))
     assert_allclose(np.fft.ifft(np.fft.ifft(x, axis=1), axis=0),
                     np.fft.ifft2(x),
                     atol=1e-6)
     assert_allclose(np.fft.ifft2(x) * np.sqrt(30 * 20),
                     np.fft.ifft2(x, norm="ortho"),
                     atol=1e-6)
Example #2
0
 def test_identity(self):
     maxlen = 512
     x = random(maxlen) + 1j * random(maxlen)
     # xr = random(maxlen)  # local variable 'xr' is assigned to but never used
     for i in range(1, maxlen):
         assert_allclose(np.fft.ifft(np.fft.fft(x[0:i])),
                         x[0:i],
                         atol=1e-12)
Example #3
0
 def test_fftn(self):
     x = random((30, 20, 10)) + 1j * random((30, 20, 10))
     assert_allclose(np.fft.fft(np.fft.fft(np.fft.fft(x, axis=2), axis=1),
                                axis=0),
                     np.fft.fftn(x),
                     atol=1e-6)
     assert_allclose(np.fft.fftn(x) / np.sqrt(30 * 20 * 10),
                     np.fft.fftn(x, norm="ortho"),
                     atol=1e-6)
Example #4
0
 def test_ifft(self, norm):
     x = random(30) + 1j * random(30)
     assert_allclose(x,
                     np.fft.ifft(np.fft.fft(x, norm=norm), norm=norm),
                     atol=1e-6)
     # Ensure we get the correct error message
     with pytest.raises(ValueError):
         # ,match='Invalid number of FFT data points'):
         np.fft.ifft([], norm=norm)
Example #5
0
 def test_hfft(self):
     x = random(14) + 1j * random(14)
     x_herm = np.concatenate((random(1), x, random(1)))
     # x = np.concatenate((x_herm, x[::-1].conj()))
     x = np.concatenate((x_herm, np.conj(x[::-1])))
     assert_allclose(np.fft.fft(x), np.fft.hfft(x_herm), atol=1e-6)
     assert_allclose(np.fft.hfft(x_herm) / np.sqrt(30),
                     np.fft.hfft(x_herm, norm="ortho"),
                     atol=1e-6)
Example #6
0
 def test_irfftn(self):
     x = random((30, 20, 10))
     assert_allclose(x, np.fft.irfftn(np.fft.rfftn(x)), atol=1e-6)
     assert_allclose(x,
                     np.fft.irfftn(np.fft.rfftn(x, norm="ortho"),
                                   norm="ortho"),
                     atol=1e-6)
Example #7
0
 def test_irfft(self):
     x = random(30)
     assert_allclose(x, np.fft.irfft(np.fft.rfft(x)), atol=1e-6)
     assert_allclose(x,
                     np.fft.irfft(np.fft.rfft(x, norm="ortho"),
                                  norm="ortho"),
                     atol=1e-6)
Example #8
0
 def _test_axes(self, op):
     x = random((30, 20, 10))
     axes = [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1),
             (2, 1, 0)]
     for a in axes:
         op_tr = op(np.transpose(x, a))
         tr_op = np.transpose(op(x, axes=a), a)
         assert_allclose(op_tr, tr_op, atol=1e-6)
Example #9
0
 def test_rfft(self):
     x = random(30)
     for n in [x.size, 2 * x.size]:
         for norm in [None, 'ortho']:
             assert_allclose(np.fft.fft(x, n=n, norm=norm)[:(n // 2 + 1)],
                             np.fft.rfft(x, n=n, norm=norm),
                             atol=1e-6)
         assert_allclose(np.fft.rfft(x, n=n) / np.sqrt(n),
                         np.fft.rfft(x, n=n, norm="ortho"),
                         atol=1e-6)
Example #10
0
 def test_all_1d_norm_preserving(self):
     # verify that round-trip transforms are norm-preserving
     x = random(30)
     # x_norm = np.linalg.norm(x)
     x_norm = numpy.linalg.norm(x)
     n = x.size * 2
     func_pairs = [
         (np.fft.fft, np.fft.ifft),
         # (np.fft.rfft, np.fft.irfft),
         # hfft: order so the first function takes x.size samples
         #       (necessary for comparison to x_norm above)
         # (np.fft.ihfft, np.fft.hfft),
     ]
     for forw, back in func_pairs:
         for n in [x.size, 2 * x.size]:
             for norm in [None, 'ortho']:
                 tmp = forw(x, n=n, norm=norm)
                 tmp = back(tmp, n=n, norm=norm)
                 assert_allclose(
                     x_norm,
                     # np.linalg.norm(tmp),
                     numpy.linalg.norm(tmp),
                     atol=1e-6)
Example #11
0
 def test_fft(self):
     x = random(30) + 1j * random(30)
     assert_allclose(fft1(x), np.fft.fft(x), atol=1e-6)
     assert_allclose(fft1(x) / np.sqrt(30),
                     np.fft.fft(x, norm="ortho"),
                     atol=1e-6)
Example #12
0
 def test_dtypes(self, dtype):
     # make sure that all input precisions are accepted and internally
     # converted to 64bit
     # x = random(30).astype(dtype)
     x = random(30).astype(dtype)
     assert_allclose(np.fft.ifft(np.fft.fft(x)), x, atol=1e-6)
Example #13
0
 def test_rfftn(self):
     x = random((30, 20, 10))
     assert_allclose(np.fft.fftn(x)[:, :, :6], np.fft.rfftn(x), atol=1e-6)
     assert_allclose(np.fft.rfftn(x) / np.sqrt(30 * 20 * 10),
                     np.fft.rfftn(x, norm="ortho"),
                     atol=1e-6)