123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364 |
- import queue
- import threading
- import multiprocessing
- import numpy as np
- import pytest
- from numpy.random import random
- from numpy.testing import (
- assert_array_almost_equal, assert_array_equal, assert_allclose
- )
- from pytest import raises as assert_raises
- import scipy.fft as fft
- def fft1(x):
- L = len(x)
- phase = -2j*np.pi*(np.arange(L)/float(L))
- phase = np.arange(L).reshape(-1, 1) * phase
- return np.sum(x*np.exp(phase), axis=1)
- class TestFFTShift:
- def test_fft_n(self):
- assert_raises(ValueError, fft.fft, [1, 2, 3], 0)
- class TestFFT1D:
- def test_identity(self):
- maxlen = 512
- x = random(maxlen) + 1j*random(maxlen)
- xr = random(maxlen)
- for i in range(1,maxlen):
- assert_array_almost_equal(fft.ifft(fft.fft(x[0:i])), x[0:i],
- decimal=12)
- assert_array_almost_equal(fft.irfft(fft.rfft(xr[0:i]),i),
- xr[0:i], decimal=12)
- def test_fft(self):
- x = random(30) + 1j*random(30)
- expect = fft1(x)
- assert_array_almost_equal(expect, fft.fft(x))
- assert_array_almost_equal(expect, fft.fft(x, norm="backward"))
- assert_array_almost_equal(expect / np.sqrt(30),
- fft.fft(x, norm="ortho"))
- assert_array_almost_equal(expect / 30, fft.fft(x, norm="forward"))
- def test_ifft(self):
- x = random(30) + 1j*random(30)
- assert_array_almost_equal(x, fft.ifft(fft.fft(x)))
- for norm in ["backward", "ortho", "forward"]:
- assert_array_almost_equal(
- x, fft.ifft(fft.fft(x, norm=norm), norm=norm))
- def test_fft2(self):
- x = random((30, 20)) + 1j*random((30, 20))
- expect = fft.fft(fft.fft(x, axis=1), axis=0)
- assert_array_almost_equal(expect, fft.fft2(x))
- assert_array_almost_equal(expect, fft.fft2(x, norm="backward"))
- assert_array_almost_equal(expect / np.sqrt(30 * 20),
- fft.fft2(x, norm="ortho"))
- assert_array_almost_equal(expect / (30 * 20),
- fft.fft2(x, norm="forward"))
- def test_ifft2(self):
- x = random((30, 20)) + 1j*random((30, 20))
- expect = fft.ifft(fft.ifft(x, axis=1), axis=0)
- assert_array_almost_equal(expect, fft.ifft2(x))
- assert_array_almost_equal(expect, fft.ifft2(x, norm="backward"))
- assert_array_almost_equal(expect * np.sqrt(30 * 20),
- fft.ifft2(x, norm="ortho"))
- assert_array_almost_equal(expect * (30 * 20),
- fft.ifft2(x, norm="forward"))
- def test_fftn(self):
- x = random((30, 20, 10)) + 1j*random((30, 20, 10))
- expect = fft.fft(fft.fft(fft.fft(x, axis=2), axis=1), axis=0)
- assert_array_almost_equal(expect, fft.fftn(x))
- assert_array_almost_equal(expect, fft.fftn(x, norm="backward"))
- assert_array_almost_equal(expect / np.sqrt(30 * 20 * 10),
- fft.fftn(x, norm="ortho"))
- assert_array_almost_equal(expect / (30 * 20 * 10),
- fft.fftn(x, norm="forward"))
- def test_ifftn(self):
- x = random((30, 20, 10)) + 1j*random((30, 20, 10))
- expect = fft.ifft(fft.ifft(fft.ifft(x, axis=2), axis=1), axis=0)
- assert_array_almost_equal(expect, fft.ifftn(x))
- assert_array_almost_equal(expect, fft.ifftn(x, norm="backward"))
- assert_array_almost_equal(fft.ifftn(x) * np.sqrt(30 * 20 * 10),
- fft.ifftn(x, norm="ortho"))
- assert_array_almost_equal(expect * (30 * 20 * 10),
- fft.ifftn(x, norm="forward"))
- def test_rfft(self):
- x = random(29)
- for n in [x.size, 2*x.size]:
- for norm in [None, "backward", "ortho", "forward"]:
- assert_array_almost_equal(
- fft.fft(x, n=n, norm=norm)[:(n//2 + 1)],
- fft.rfft(x, n=n, norm=norm))
- assert_array_almost_equal(fft.rfft(x, n=n) / np.sqrt(n),
- fft.rfft(x, n=n, norm="ortho"))
- def test_irfft(self):
- x = random(30)
- assert_array_almost_equal(x, fft.irfft(fft.rfft(x)))
- for norm in ["backward", "ortho", "forward"]:
- assert_array_almost_equal(
- x, fft.irfft(fft.rfft(x, norm=norm), norm=norm))
- def test_rfft2(self):
- x = random((30, 20))
- expect = fft.fft2(x)[:, :11]
- assert_array_almost_equal(expect, fft.rfft2(x))
- assert_array_almost_equal(expect, fft.rfft2(x, norm="backward"))
- assert_array_almost_equal(expect / np.sqrt(30 * 20),
- fft.rfft2(x, norm="ortho"))
- assert_array_almost_equal(expect / (30 * 20),
- fft.rfft2(x, norm="forward"))
- def test_irfft2(self):
- x = random((30, 20))
- assert_array_almost_equal(x, fft.irfft2(fft.rfft2(x)))
- for norm in ["backward", "ortho", "forward"]:
- assert_array_almost_equal(
- x, fft.irfft2(fft.rfft2(x, norm=norm), norm=norm))
- def test_rfftn(self):
- x = random((30, 20, 10))
- expect = fft.fftn(x)[:, :, :6]
- assert_array_almost_equal(expect, fft.rfftn(x))
- assert_array_almost_equal(expect, fft.rfftn(x, norm="backward"))
- assert_array_almost_equal(expect / np.sqrt(30 * 20 * 10),
- fft.rfftn(x, norm="ortho"))
- assert_array_almost_equal(expect / (30 * 20 * 10),
- fft.rfftn(x, norm="forward"))
- def test_irfftn(self):
- x = random((30, 20, 10))
- assert_array_almost_equal(x, fft.irfftn(fft.rfftn(x)))
- for norm in ["backward", "ortho", "forward"]:
- assert_array_almost_equal(
- x, fft.irfftn(fft.rfftn(x, norm=norm), norm=norm))
- 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()))
- expect = fft.fft(x)
- assert_array_almost_equal(expect, fft.hfft(x_herm))
- assert_array_almost_equal(expect, fft.hfft(x_herm, norm="backward"))
- assert_array_almost_equal(expect / np.sqrt(30),
- fft.hfft(x_herm, norm="ortho"))
- assert_array_almost_equal(expect / 30,
- fft.hfft(x_herm, norm="forward"))
- def test_ihfft(self):
- x = random(14) + 1j*random(14)
- x_herm = np.concatenate((random(1), x, random(1)))
- x = np.concatenate((x_herm, x[::-1].conj()))
- assert_array_almost_equal(x_herm, fft.ihfft(fft.hfft(x_herm)))
- for norm in ["backward", "ortho", "forward"]:
- assert_array_almost_equal(
- x_herm, fft.ihfft(fft.hfft(x_herm, norm=norm), norm=norm))
- def test_hfft2(self):
- x = random((30, 20))
- assert_array_almost_equal(x, fft.hfft2(fft.ihfft2(x)))
- for norm in ["backward", "ortho", "forward"]:
- assert_array_almost_equal(
- x, fft.hfft2(fft.ihfft2(x, norm=norm), norm=norm))
- def test_ihfft2(self):
- x = random((30, 20))
- expect = fft.ifft2(x)[:, :11]
- assert_array_almost_equal(expect, fft.ihfft2(x))
- assert_array_almost_equal(expect, fft.ihfft2(x, norm="backward"))
- assert_array_almost_equal(expect * np.sqrt(30 * 20),
- fft.ihfft2(x, norm="ortho"))
- assert_array_almost_equal(expect * (30 * 20),
- fft.ihfft2(x, norm="forward"))
- def test_hfftn(self):
- x = random((30, 20, 10))
- assert_array_almost_equal(x, fft.hfftn(fft.ihfftn(x)))
- for norm in ["backward", "ortho", "forward"]:
- assert_array_almost_equal(
- x, fft.hfftn(fft.ihfftn(x, norm=norm), norm=norm))
- def test_ihfftn(self):
- x = random((30, 20, 10))
- expect = fft.ifftn(x)[:, :, :6]
- assert_array_almost_equal(expect, fft.ihfftn(x))
- assert_array_almost_equal(expect, fft.ihfftn(x, norm="backward"))
- assert_array_almost_equal(expect * np.sqrt(30 * 20 * 10),
- fft.ihfftn(x, norm="ortho"))
- assert_array_almost_equal(expect * (30 * 20 * 10),
- fft.ihfftn(x, norm="forward"))
- @pytest.mark.parametrize("op", [fft.fftn, fft.ifftn,
- fft.rfftn, fft.irfftn,
- fft.hfftn, fft.ihfftn])
- 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_array_almost_equal(op_tr, tr_op)
- @pytest.mark.parametrize("op", [fft.fft2, fft.ifft2,
- fft.rfft2, fft.irfft2,
- fft.hfft2, fft.ihfft2,
- fft.fftn, fft.ifftn,
- fft.rfftn, fft.irfftn,
- fft.hfftn, fft.ihfftn])
- def test_axes_subset_with_shape(self, op):
- x = random((16, 8, 4))
- axes = [(0, 1, 2), (0, 2, 1), (1, 2, 0)]
- for a in axes:
- # different shape on the first two axes
- shape = tuple([2*x.shape[ax] if ax in a[:2] else x.shape[ax]
- for ax in range(x.ndim)])
- # transform only the first two axes
- op_tr = op(np.transpose(x, a), s=shape[:2], axes=(0, 1))
- tr_op = np.transpose(op(x, s=shape[:2], axes=a[:2]), a)
- assert_array_almost_equal(op_tr, tr_op)
- def test_all_1d_norm_preserving(self):
- # verify that round-trip transforms are norm-preserving
- x = random(30)
- x_norm = np.linalg.norm(x)
- n = x.size * 2
- func_pairs = [(fft.fft, fft.ifft),
- (fft.rfft, fft.irfft),
- # hfft: order so the first function takes x.size samples
- # (necessary for comparison to x_norm above)
- (fft.ihfft, fft.hfft),
- ]
- for forw, back in func_pairs:
- for n in [x.size, 2*x.size]:
- for norm in ['backward', 'ortho', 'forward']:
- tmp = forw(x, n=n, norm=norm)
- tmp = back(tmp, n=n, norm=norm)
- assert_array_almost_equal(x_norm,
- np.linalg.norm(tmp))
- @pytest.mark.parametrize("dtype", [np.half, np.single, np.double,
- np.longdouble])
- def test_dtypes(self, dtype):
- # make sure that all input precisions are accepted
- x = random(30).astype(dtype)
- assert_array_almost_equal(fft.ifft(fft.fft(x)), x)
- assert_array_almost_equal(fft.irfft(fft.rfft(x)), x)
- assert_array_almost_equal(fft.hfft(fft.ihfft(x), len(x)), x)
- @pytest.mark.parametrize(
- "dtype",
- [np.float32, np.float64, np.longfloat,
- np.complex64, np.complex128, np.longcomplex])
- @pytest.mark.parametrize("order", ["F", 'non-contiguous'])
- @pytest.mark.parametrize(
- "fft",
- [fft.fft, fft.fft2, fft.fftn,
- fft.ifft, fft.ifft2, fft.ifftn])
- def test_fft_with_order(dtype, order, fft):
- # Check that FFT/IFFT produces identical results for C, Fortran and
- # non contiguous arrays
- rng = np.random.RandomState(42)
- X = rng.rand(8, 7, 13).astype(dtype, copy=False)
- if order == 'F':
- Y = np.asfortranarray(X)
- else:
- # Make a non contiguous array
- Y = X[::-1]
- X = np.ascontiguousarray(X[::-1])
- if fft.__name__.endswith('fft'):
- for axis in range(3):
- X_res = fft(X, axis=axis)
- Y_res = fft(Y, axis=axis)
- assert_array_almost_equal(X_res, Y_res)
- elif fft.__name__.endswith(('fft2', 'fftn')):
- axes = [(0, 1), (1, 2), (0, 2)]
- if fft.__name__.endswith('fftn'):
- axes.extend([(0,), (1,), (2,), None])
- for ax in axes:
- X_res = fft(X, axes=ax)
- Y_res = fft(Y, axes=ax)
- assert_array_almost_equal(X_res, Y_res)
- else:
- raise ValueError
- class TestFFTThreadSafe:
- threads = 16
- input_shape = (800, 200)
- def _test_mtsame(self, func, *args):
- def worker(args, q):
- q.put(func(*args))
- q = queue.Queue()
- expected = func(*args)
- # Spin off a bunch of threads to call the same function simultaneously
- t = [threading.Thread(target=worker, args=(args, q))
- for i in range(self.threads)]
- [x.start() for x in t]
- [x.join() for x in t]
- # Make sure all threads returned the correct value
- for i in range(self.threads):
- assert_array_equal(q.get(timeout=5), expected,
- 'Function returned wrong value in multithreaded context')
- def test_fft(self):
- a = np.ones(self.input_shape, dtype=np.complex128)
- self._test_mtsame(fft.fft, a)
- def test_ifft(self):
- a = np.full(self.input_shape, 1+0j)
- self._test_mtsame(fft.ifft, a)
- def test_rfft(self):
- a = np.ones(self.input_shape)
- self._test_mtsame(fft.rfft, a)
- def test_irfft(self):
- a = np.full(self.input_shape, 1+0j)
- self._test_mtsame(fft.irfft, a)
- def test_hfft(self):
- a = np.ones(self.input_shape, np.complex64)
- self._test_mtsame(fft.hfft, a)
- def test_ihfft(self):
- a = np.ones(self.input_shape)
- self._test_mtsame(fft.ihfft, a)
- @pytest.mark.parametrize("func", [fft.fft, fft.ifft, fft.rfft, fft.irfft])
- def test_multiprocess(func):
- # Test that fft still works after fork (gh-10422)
- with multiprocessing.Pool(2) as p:
- res = p.map(func, [np.ones(100) for _ in range(4)])
- expect = func(np.ones(100))
- for x in res:
- assert_allclose(x, expect)
- class TestIRFFTN:
- def test_not_last_axis_success(self):
- ar, ai = np.random.random((2, 16, 8, 32))
- a = ar + 1j*ai
- axes = (-2,)
- # Should not raise error
- fft.irfftn(a, axes=axes)
|