def test_definition(self):
x = np.array([1, 2, 3, 4 + 1j, 1, 2, 3, 4 + 2j], dtype=self.cdt)
y = fft(x)
assert_equal(y.dtype, self.cdt)
y1 = direct_dft(x)
assert_array_almost_equal(y, y1)
x = np.array([1, 2, 3, 4 + 0j, 5], dtype=self.cdt)
assert_array_almost_equal(fft(x), direct_dft(x))
def test_random_real(self):
for size in [1, 51, 111, 100, 200, 64, 128, 256, 1024]:
x = random([size]).astype(self.rdt)
y1 = ifft(fft(x))
y2 = fft(ifft(x))
assert_equal(y1.dtype, self.cdt)
assert_equal(y2.dtype, self.cdt)
assert_array_almost_equal(y1, x)
assert_array_almost_equal(y2, x)
def test_windowfunc_basics():
for window_name, params in window_funcs:
window = getattr(signal, window_name)
with suppress_warnings() as sup:
sup.filter(UserWarning, "This window is not suitable")
# Check symmetry for odd and even lengths
w1 = window(8, *params, sym=True)
w2 = window(7, *params, sym=False)
assert_array_almost_equal(w1[:-1], w2)
w1 = window(9, *params, sym=True)
w2 = window(8, *params, sym=False)
assert_array_almost_equal(w1[:-1], w2)
# Check that functions run and output lengths are correct
assert_equal(len(window(6, *params, sym=True)), 6)
assert_equal(len(window(6, *params, sym=False)), 6)
assert_equal(len(window(7, *params, sym=True)), 7)
assert_equal(len(window(7, *params, sym=False)), 7)
# Check invalid lengths
assert_raises(ValueError, window, 5.5, *params)
assert_raises(ValueError, window, -7, *params)
# Check degenerate cases
assert_array_equal(window(0, *params, sym=True), [])
assert_array_equal(window(0, *params, sym=False), [])
assert_array_equal(window(1, *params, sym=True), [1])
assert_array_equal(window(1, *params, sym=False), [1])
# Check dtype
assert_(window(0, *params, sym=True).dtype == 'float')
assert_(window(0, *params, sym=False).dtype == 'float')
assert_(window(1, *params, sym=True).dtype == 'float')
assert_(window(1, *params, sym=False).dtype == 'float')
assert_(window(6, *params, sym=True).dtype == 'float')
assert_(window(6, *params, sym=False).dtype == 'float')
# Check normalization
#assert_array_less(window(10, *params, sym=True), 1.01)
# assert_array_less(window(10, *params, sym=False), 1.01)
# assert_array_less(window(9, *params, sym=True), 1.01)
# assert_array_less(window(9, *params, sym=False), 1.01)
# Check that DFT-even spectrum is purely real for odd and even
assert_allclose(fftpack.fft(window(10, *params, sym=False)).imag,
0,
atol=1e-14)
assert_allclose(fftpack.fft(window(11, *params, sym=False)).imag,
0,
atol=1e-14)
def test_shape_axes_argument2(self):
# Change shape of the last axis
x = numpy.random.random((10, 5, 3, 7))
y = fftn(x, axes=(-1, ), shape=(8, ))
assert_array_almost_equal(y, fft(x, axis=-1, n=8))
# Change shape of an arbitrary axis which is not the last one
x = numpy.random.random((10, 5, 3, 7))
y = fftn(x, axes=(-2, ), shape=(8, ))
assert_array_almost_equal(y, fft(x, axis=-2, n=8))
# Change shape of axes: cf #244, where shape and axes were mixed up
x = numpy.random.random((4, 4, 2))
y = fftn(x, axes=(-3, -2), shape=(8, 8))
assert_array_almost_equal(y, numpy.fft.fftn(x, axes=(-3, -2),
s=(8, 8)))
def direct_shift(x, a, period=None):
n = len(x)
if period is None:
k = fftfreq(n) * 1j * n
else:
k = fftfreq(n) * 2j * pi / period * n
return ifft(fft(x) * exp(k * a)).real
def test_n_argument_real(self):
x1 = np.array([1, 2, 3, 4], dtype=np.float16)
x2 = np.array([1, 2, 3, 4], dtype=np.float16)
y = fft([x1, x2], n=4)
assert_equal(y.dtype, np.complex64)
assert_equal(y.shape, (2, 4))
assert_array_almost_equal(y[0], direct_dft(x1.astype(np.float32)))
assert_array_almost_equal(y[1], direct_dft(x2.astype(np.float32)))
def _test_n_argument_complex(self):
x1 = np.array([1, 2, 3, 4 + 1j], dtype=self.cdt)
x2 = np.array([1, 2, 3, 4 + 1j], dtype=self.cdt)
y = fft([x1, x2], n=4)
assert_equal(y.dtype, self.cdt)
assert_equal(y.shape, (2, 4))
assert_array_almost_equal(y[0], direct_dft(x1))
assert_array_almost_equal(y[1], direct_dft(x2))
def direct_itilbert(x, h=1, period=None):
fx = fft(x)
n = len(fx)
if period is None:
period = 2 * pi
w = fftfreq(n) * h * 2 * pi / period * n
w = -1j * tanh(w)
return ifft(w * fx)
def direct_tilbert(x, h=1, period=None):
fx = fft(x)
n = len(fx)
if period is None:
period = 2 * pi
w = fftfreq(n) * h * 2 * pi / period * n
w[0] = 1
w = 1j / tanh(w)
w[0] = 0j
return ifft(w * fx)
def test_size_accuracy(self):
# Sanity check for the accuracy for prime and non-prime sized inputs
if self.rdt == np.float32:
rtol = 1e-5
elif self.rdt == np.float64:
rtol = 1e-10
for size in LARGE_COMPOSITE_SIZES + LARGE_PRIME_SIZES:
np.random.seed(1234)
x = np.random.rand(size).astype(self.rdt)
y = ifft(fft(x))
_assert_close_in_norm(x, y, rtol, size, self.rdt)
y = fft(ifft(x))
_assert_close_in_norm(x, y, rtol, size, self.rdt)
x = (x + 1j * np.random.rand(size)).astype(self.cdt)
y = ifft(fft(x))
_assert_close_in_norm(x, y, rtol, size, self.rdt)
y = fft(ifft(x))
_assert_close_in_norm(x, y, rtol, size, self.rdt)
def direct_diff(x, k=1, period=None):
fx = fft(x)
n = len(fx)
if period is None:
period = 2 * pi
w = fftfreq(n) * 2j * pi / period * n
if k < 0:
w = 1 / w**k
w[0] = 0.0
else:
w = w**k
if n > 2000:
w[250:n - 250] = 0.0
return ifft(w * fx).real
def direct_dftn(x):
x = asarray(x)
for axis in range(len(x.shape)):
x = fft(x, axis=axis)
return x
def test_axes_argument(self):
# plane == ji_plane, x== kji_space
plane1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
plane2 = [[10, 11, 12], [13, 14, 15], [16, 17, 18]]
plane3 = [[19, 20, 21], [22, 23, 24], [25, 26, 27]]
ki_plane1 = [[1, 2, 3], [10, 11, 12], [19, 20, 21]]
ki_plane2 = [[4, 5, 6], [13, 14, 15], [22, 23, 24]]
ki_plane3 = [[7, 8, 9], [16, 17, 18], [25, 26, 27]]
jk_plane1 = [[1, 10, 19], [4, 13, 22], [7, 16, 25]]
jk_plane2 = [[2, 11, 20], [5, 14, 23], [8, 17, 26]]
jk_plane3 = [[3, 12, 21], [6, 15, 24], [9, 18, 27]]
kj_plane1 = [[1, 4, 7], [10, 13, 16], [19, 22, 25]]
kj_plane2 = [[2, 5, 8], [11, 14, 17], [20, 23, 26]]
kj_plane3 = [[3, 6, 9], [12, 15, 18], [21, 24, 27]]
ij_plane1 = [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
ij_plane2 = [[10, 13, 16], [11, 14, 17], [12, 15, 18]]
ij_plane3 = [[19, 22, 25], [20, 23, 26], [21, 24, 27]]
ik_plane1 = [[1, 10, 19], [2, 11, 20], [3, 12, 21]]
ik_plane2 = [[4, 13, 22], [5, 14, 23], [6, 15, 24]]
ik_plane3 = [[7, 16, 25], [8, 17, 26], [9, 18, 27]]
ijk_space = [jk_plane1, jk_plane2, jk_plane3]
ikj_space = [kj_plane1, kj_plane2, kj_plane3]
jik_space = [ik_plane1, ik_plane2, ik_plane3]
jki_space = [ki_plane1, ki_plane2, ki_plane3]
kij_space = [ij_plane1, ij_plane2, ij_plane3]
x = array([plane1, plane2, plane3])
assert_array_almost_equal(fftn(x),
fftn(x, axes=(-3, -2, -1))) # kji_space
assert_array_almost_equal(fftn(x), fftn(x, axes=(0, 1, 2)))
assert_array_almost_equal(fftn(x, axes=(0, 2)), fftn(x, axes=(0, -1)))
y = fftn(x, axes=(2, 1, 0)) # ijk_space
assert_array_almost_equal(swapaxes(y, -1, -3), fftn(ijk_space))
y = fftn(x, axes=(2, 0, 1)) # ikj_space
assert_array_almost_equal(swapaxes(swapaxes(y, -1, -3), -1, -2),
fftn(ikj_space))
y = fftn(x, axes=(1, 2, 0)) # jik_space
assert_array_almost_equal(swapaxes(swapaxes(y, -1, -3), -3, -2),
fftn(jik_space))
y = fftn(x, axes=(1, 0, 2)) # jki_space
assert_array_almost_equal(swapaxes(y, -2, -3), fftn(jki_space))
y = fftn(x, axes=(0, 2, 1)) # kij_space
assert_array_almost_equal(swapaxes(y, -2, -1), fftn(kij_space))
y = fftn(x, axes=(-2, -1)) # ji_plane
assert_array_almost_equal(fftn(plane1), y[0])
assert_array_almost_equal(fftn(plane2), y[1])
assert_array_almost_equal(fftn(plane3), y[2])
y = fftn(x, axes=(1, 2)) # ji_plane
assert_array_almost_equal(fftn(plane1), y[0])
assert_array_almost_equal(fftn(plane2), y[1])
assert_array_almost_equal(fftn(plane3), y[2])
y = fftn(x, axes=(-3, -2)) # kj_plane
assert_array_almost_equal(fftn(x[:, :, 0]), y[:, :, 0])
assert_array_almost_equal(fftn(x[:, :, 1]), y[:, :, 1])
assert_array_almost_equal(fftn(x[:, :, 2]), y[:, :, 2])
y = fftn(x, axes=(-3, -1)) # ki_plane
assert_array_almost_equal(fftn(x[:, 0, :]), y[:, 0, :])
assert_array_almost_equal(fftn(x[:, 1, :]), y[:, 1, :])
assert_array_almost_equal(fftn(x[:, 2, :]), y[:, 2, :])
y = fftn(x, axes=(-1, -2)) # ij_plane
assert_array_almost_equal(fftn(ij_plane1), swapaxes(y[0], -2, -1))
assert_array_almost_equal(fftn(ij_plane2), swapaxes(y[1], -2, -1))
assert_array_almost_equal(fftn(ij_plane3), swapaxes(y[2], -2, -1))
y = fftn(x, axes=(-1, -3)) # ik_plane
assert_array_almost_equal(fftn(ik_plane1),
swapaxes(y[:, 0, :], -1, -2))
assert_array_almost_equal(fftn(ik_plane2),
swapaxes(y[:, 1, :], -1, -2))
assert_array_almost_equal(fftn(ik_plane3),
swapaxes(y[:, 2, :], -1, -2))
y = fftn(x, axes=(-2, -3)) # jk_plane
assert_array_almost_equal(fftn(jk_plane1),
swapaxes(y[:, :, 0], -1, -2))
assert_array_almost_equal(fftn(jk_plane2),
swapaxes(y[:, :, 1], -1, -2))
assert_array_almost_equal(fftn(jk_plane3),
swapaxes(y[:, :, 2], -1, -2))
y = fftn(x, axes=(-1, )) # i_line
for i in range(3):
for j in range(3):
assert_array_almost_equal(fft(x[i, j, :]), y[i, j, :])
y = fftn(x, axes=(-2, )) # j_line
for i in range(3):
for j in range(3):
assert_array_almost_equal(fft(x[i, :, j]), y[i, :, j])
y = fftn(x, axes=(0, )) # k_line
for i in range(3):
for j in range(3):
assert_array_almost_equal(fft(x[:, i, j]), y[:, i, j])
y = fftn(x, axes=()) # point
assert_array_almost_equal(y, x)
def test_1_argument_real(self):
x1 = np.array([1, 2, 3, 4], dtype=np.float16)
y = fft(x1, n=4)
assert_equal(y.dtype, np.complex64)
assert_equal(y.shape, (4, ))
assert_array_almost_equal(y, direct_dft(x1.astype(np.float32)))
def direct_hilbert(x):
fx = fft(x)
n = len(fx)
w = fftfreq(n) * n
w = 1j * sign(w)
return ifft(w * fx)