done
This commit is contained in:
167
lib/python3.11/site-packages/numpy/fft/tests/test_helper.py
Normal file
167
lib/python3.11/site-packages/numpy/fft/tests/test_helper.py
Normal file
@ -0,0 +1,167 @@
|
||||
"""Test functions for fftpack.helper module
|
||||
|
||||
Copied from fftpack.helper by Pearu Peterson, October 2005
|
||||
|
||||
"""
|
||||
import numpy as np
|
||||
from numpy import fft, pi
|
||||
from numpy.testing import assert_array_almost_equal
|
||||
|
||||
|
||||
class TestFFTShift:
|
||||
|
||||
def test_definition(self):
|
||||
x = [0, 1, 2, 3, 4, -4, -3, -2, -1]
|
||||
y = [-4, -3, -2, -1, 0, 1, 2, 3, 4]
|
||||
assert_array_almost_equal(fft.fftshift(x), y)
|
||||
assert_array_almost_equal(fft.ifftshift(y), x)
|
||||
x = [0, 1, 2, 3, 4, -5, -4, -3, -2, -1]
|
||||
y = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
|
||||
assert_array_almost_equal(fft.fftshift(x), y)
|
||||
assert_array_almost_equal(fft.ifftshift(y), x)
|
||||
|
||||
def test_inverse(self):
|
||||
for n in [1, 4, 9, 100, 211]:
|
||||
x = np.random.random((n,))
|
||||
assert_array_almost_equal(fft.ifftshift(fft.fftshift(x)), x)
|
||||
|
||||
def test_axes_keyword(self):
|
||||
freqs = [[0, 1, 2], [3, 4, -4], [-3, -2, -1]]
|
||||
shifted = [[-1, -3, -2], [2, 0, 1], [-4, 3, 4]]
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=(0, 1)), shifted)
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=0),
|
||||
fft.fftshift(freqs, axes=(0,)))
|
||||
assert_array_almost_equal(fft.ifftshift(shifted, axes=(0, 1)), freqs)
|
||||
assert_array_almost_equal(fft.ifftshift(shifted, axes=0),
|
||||
fft.ifftshift(shifted, axes=(0,)))
|
||||
|
||||
assert_array_almost_equal(fft.fftshift(freqs), shifted)
|
||||
assert_array_almost_equal(fft.ifftshift(shifted), freqs)
|
||||
|
||||
def test_uneven_dims(self):
|
||||
""" Test 2D input, which has uneven dimension sizes """
|
||||
freqs = [
|
||||
[0, 1],
|
||||
[2, 3],
|
||||
[4, 5]
|
||||
]
|
||||
|
||||
# shift in dimension 0
|
||||
shift_dim0 = [
|
||||
[4, 5],
|
||||
[0, 1],
|
||||
[2, 3]
|
||||
]
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=0), shift_dim0)
|
||||
assert_array_almost_equal(fft.ifftshift(shift_dim0, axes=0), freqs)
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=(0,)), shift_dim0)
|
||||
assert_array_almost_equal(fft.ifftshift(shift_dim0, axes=[0]), freqs)
|
||||
|
||||
# shift in dimension 1
|
||||
shift_dim1 = [
|
||||
[1, 0],
|
||||
[3, 2],
|
||||
[5, 4]
|
||||
]
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=1), shift_dim1)
|
||||
assert_array_almost_equal(fft.ifftshift(shift_dim1, axes=1), freqs)
|
||||
|
||||
# shift in both dimensions
|
||||
shift_dim_both = [
|
||||
[5, 4],
|
||||
[1, 0],
|
||||
[3, 2]
|
||||
]
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=(0, 1)), shift_dim_both)
|
||||
assert_array_almost_equal(fft.ifftshift(shift_dim_both, axes=(0, 1)), freqs)
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=[0, 1]), shift_dim_both)
|
||||
assert_array_almost_equal(fft.ifftshift(shift_dim_both, axes=[0, 1]), freqs)
|
||||
|
||||
# axes=None (default) shift in all dimensions
|
||||
assert_array_almost_equal(fft.fftshift(freqs, axes=None), shift_dim_both)
|
||||
assert_array_almost_equal(fft.ifftshift(shift_dim_both, axes=None), freqs)
|
||||
assert_array_almost_equal(fft.fftshift(freqs), shift_dim_both)
|
||||
assert_array_almost_equal(fft.ifftshift(shift_dim_both), freqs)
|
||||
|
||||
def test_equal_to_original(self):
|
||||
""" Test the new (>=v1.15) and old implementations are equal (see #10073) """
|
||||
from numpy._core import arange, asarray, concatenate, take
|
||||
|
||||
def original_fftshift(x, axes=None):
|
||||
""" How fftshift was implemented in v1.14"""
|
||||
tmp = asarray(x)
|
||||
ndim = tmp.ndim
|
||||
if axes is None:
|
||||
axes = list(range(ndim))
|
||||
elif isinstance(axes, int):
|
||||
axes = (axes,)
|
||||
y = tmp
|
||||
for k in axes:
|
||||
n = tmp.shape[k]
|
||||
p2 = (n + 1) // 2
|
||||
mylist = concatenate((arange(p2, n), arange(p2)))
|
||||
y = take(y, mylist, k)
|
||||
return y
|
||||
|
||||
def original_ifftshift(x, axes=None):
|
||||
""" How ifftshift was implemented in v1.14 """
|
||||
tmp = asarray(x)
|
||||
ndim = tmp.ndim
|
||||
if axes is None:
|
||||
axes = list(range(ndim))
|
||||
elif isinstance(axes, int):
|
||||
axes = (axes,)
|
||||
y = tmp
|
||||
for k in axes:
|
||||
n = tmp.shape[k]
|
||||
p2 = n - (n + 1) // 2
|
||||
mylist = concatenate((arange(p2, n), arange(p2)))
|
||||
y = take(y, mylist, k)
|
||||
return y
|
||||
|
||||
# create possible 2d array combinations and try all possible keywords
|
||||
# compare output to original functions
|
||||
for i in range(16):
|
||||
for j in range(16):
|
||||
for axes_keyword in [0, 1, None, (0,), (0, 1)]:
|
||||
inp = np.random.rand(i, j)
|
||||
|
||||
assert_array_almost_equal(fft.fftshift(inp, axes_keyword),
|
||||
original_fftshift(inp, axes_keyword))
|
||||
|
||||
assert_array_almost_equal(fft.ifftshift(inp, axes_keyword),
|
||||
original_ifftshift(inp, axes_keyword))
|
||||
|
||||
|
||||
class TestFFTFreq:
|
||||
|
||||
def test_definition(self):
|
||||
x = [0, 1, 2, 3, 4, -4, -3, -2, -1]
|
||||
assert_array_almost_equal(9 * fft.fftfreq(9), x)
|
||||
assert_array_almost_equal(9 * pi * fft.fftfreq(9, pi), x)
|
||||
x = [0, 1, 2, 3, 4, -5, -4, -3, -2, -1]
|
||||
assert_array_almost_equal(10 * fft.fftfreq(10), x)
|
||||
assert_array_almost_equal(10 * pi * fft.fftfreq(10, pi), x)
|
||||
|
||||
|
||||
class TestRFFTFreq:
|
||||
|
||||
def test_definition(self):
|
||||
x = [0, 1, 2, 3, 4]
|
||||
assert_array_almost_equal(9 * fft.rfftfreq(9), x)
|
||||
assert_array_almost_equal(9 * pi * fft.rfftfreq(9, pi), x)
|
||||
x = [0, 1, 2, 3, 4, 5]
|
||||
assert_array_almost_equal(10 * fft.rfftfreq(10), x)
|
||||
assert_array_almost_equal(10 * pi * fft.rfftfreq(10, pi), x)
|
||||
|
||||
|
||||
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)
|
||||
589
lib/python3.11/site-packages/numpy/fft/tests/test_pocketfft.py
Normal file
589
lib/python3.11/site-packages/numpy/fft/tests/test_pocketfft.py
Normal file
@ -0,0 +1,589 @@
|
||||
import queue
|
||||
import threading
|
||||
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
from numpy.random import random
|
||||
from numpy.testing import IS_WASM, assert_allclose, assert_array_equal, assert_raises
|
||||
|
||||
|
||||
def fft1(x):
|
||||
L = len(x)
|
||||
phase = -2j * np.pi * (np.arange(L) / 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, np.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_allclose(np.fft.ifft(np.fft.fft(x[0:i])), x[0:i],
|
||||
atol=1e-12)
|
||||
assert_allclose(np.fft.irfft(np.fft.rfft(xr[0:i]), i),
|
||||
xr[0:i], atol=1e-12)
|
||||
|
||||
@pytest.mark.parametrize("dtype", [np.single, np.double, np.longdouble])
|
||||
def test_identity_long_short(self, dtype):
|
||||
# Test with explicitly given number of points, both for n
|
||||
# smaller and for n larger than the input size.
|
||||
maxlen = 16
|
||||
atol = 5 * np.spacing(np.array(1., dtype=dtype))
|
||||
x = random(maxlen).astype(dtype) + 1j * random(maxlen).astype(dtype)
|
||||
xx = np.concatenate([x, np.zeros_like(x)])
|
||||
xr = random(maxlen).astype(dtype)
|
||||
xxr = np.concatenate([xr, np.zeros_like(xr)])
|
||||
for i in range(1, maxlen * 2):
|
||||
check_c = np.fft.ifft(np.fft.fft(x, n=i), n=i)
|
||||
assert check_c.real.dtype == dtype
|
||||
assert_allclose(check_c, xx[0:i], atol=atol, rtol=0)
|
||||
check_r = np.fft.irfft(np.fft.rfft(xr, n=i), n=i)
|
||||
assert check_r.dtype == dtype
|
||||
assert_allclose(check_r, xxr[0:i], atol=atol, rtol=0)
|
||||
|
||||
@pytest.mark.parametrize("dtype", [np.single, np.double, np.longdouble])
|
||||
def test_identity_long_short_reversed(self, dtype):
|
||||
# Also test explicitly given number of points in reversed order.
|
||||
maxlen = 16
|
||||
atol = 5 * np.spacing(np.array(1., dtype=dtype))
|
||||
x = random(maxlen).astype(dtype) + 1j * random(maxlen).astype(dtype)
|
||||
xx = np.concatenate([x, np.zeros_like(x)])
|
||||
for i in range(1, maxlen * 2):
|
||||
check_via_c = np.fft.fft(np.fft.ifft(x, n=i), n=i)
|
||||
assert check_via_c.dtype == x.dtype
|
||||
assert_allclose(check_via_c, xx[0:i], atol=atol, rtol=0)
|
||||
# For irfft, we can neither recover the imaginary part of
|
||||
# the first element, nor the imaginary part of the last
|
||||
# element if npts is even. So, set to 0 for the comparison.
|
||||
y = x.copy()
|
||||
n = i // 2 + 1
|
||||
y.imag[0] = 0
|
||||
if i % 2 == 0:
|
||||
y.imag[n - 1:] = 0
|
||||
yy = np.concatenate([y, np.zeros_like(y)])
|
||||
check_via_r = np.fft.rfft(np.fft.irfft(x, n=i), n=i)
|
||||
assert check_via_r.dtype == x.dtype
|
||||
assert_allclose(check_via_r, yy[0:n], atol=atol, rtol=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.fft.fft(x, norm="backward"), atol=1e-6)
|
||||
assert_allclose(fft1(x) / np.sqrt(30),
|
||||
np.fft.fft(x, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(fft1(x) / 30.,
|
||||
np.fft.fft(x, norm="forward"), atol=1e-6)
|
||||
|
||||
@pytest.mark.parametrize("axis", (0, 1))
|
||||
@pytest.mark.parametrize("dtype", (complex, float))
|
||||
@pytest.mark.parametrize("transpose", (True, False))
|
||||
def test_fft_out_argument(self, dtype, transpose, axis):
|
||||
def zeros_like(x):
|
||||
if transpose:
|
||||
return np.zeros_like(x.T).T
|
||||
else:
|
||||
return np.zeros_like(x)
|
||||
|
||||
# tests below only test the out parameter
|
||||
if dtype is complex:
|
||||
y = random((10, 20)) + 1j * random((10, 20))
|
||||
fft, ifft = np.fft.fft, np.fft.ifft
|
||||
else:
|
||||
y = random((10, 20))
|
||||
fft, ifft = np.fft.rfft, np.fft.irfft
|
||||
|
||||
expected = fft(y, axis=axis)
|
||||
out = zeros_like(expected)
|
||||
result = fft(y, out=out, axis=axis)
|
||||
assert result is out
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
expected2 = ifft(expected, axis=axis)
|
||||
out2 = out if dtype is complex else zeros_like(expected2)
|
||||
result2 = ifft(out, out=out2, axis=axis)
|
||||
assert result2 is out2
|
||||
assert_array_equal(result2, expected2)
|
||||
|
||||
@pytest.mark.parametrize("axis", [0, 1])
|
||||
def test_fft_inplace_out(self, axis):
|
||||
# Test some weirder in-place combinations
|
||||
y = random((20, 20)) + 1j * random((20, 20))
|
||||
# Fully in-place.
|
||||
y1 = y.copy()
|
||||
expected1 = np.fft.fft(y1, axis=axis)
|
||||
result1 = np.fft.fft(y1, axis=axis, out=y1)
|
||||
assert result1 is y1
|
||||
assert_array_equal(result1, expected1)
|
||||
# In-place of part of the array; rest should be unchanged.
|
||||
y2 = y.copy()
|
||||
out2 = y2[:10] if axis == 0 else y2[:, :10]
|
||||
expected2 = np.fft.fft(y2, n=10, axis=axis)
|
||||
result2 = np.fft.fft(y2, n=10, axis=axis, out=out2)
|
||||
assert result2 is out2
|
||||
assert_array_equal(result2, expected2)
|
||||
if axis == 0:
|
||||
assert_array_equal(y2[10:], y[10:])
|
||||
else:
|
||||
assert_array_equal(y2[:, 10:], y[:, 10:])
|
||||
# In-place of another part of the array.
|
||||
y3 = y.copy()
|
||||
y3_sel = y3[5:] if axis == 0 else y3[:, 5:]
|
||||
out3 = y3[5:15] if axis == 0 else y3[:, 5:15]
|
||||
expected3 = np.fft.fft(y3_sel, n=10, axis=axis)
|
||||
result3 = np.fft.fft(y3_sel, n=10, axis=axis, out=out3)
|
||||
assert result3 is out3
|
||||
assert_array_equal(result3, expected3)
|
||||
if axis == 0:
|
||||
assert_array_equal(y3[:5], y[:5])
|
||||
assert_array_equal(y3[15:], y[15:])
|
||||
else:
|
||||
assert_array_equal(y3[:, :5], y[:, :5])
|
||||
assert_array_equal(y3[:, 15:], y[:, 15:])
|
||||
# In-place with n > nin; rest should be unchanged.
|
||||
y4 = y.copy()
|
||||
y4_sel = y4[:10] if axis == 0 else y4[:, :10]
|
||||
out4 = y4[:15] if axis == 0 else y4[:, :15]
|
||||
expected4 = np.fft.fft(y4_sel, n=15, axis=axis)
|
||||
result4 = np.fft.fft(y4_sel, n=15, axis=axis, out=out4)
|
||||
assert result4 is out4
|
||||
assert_array_equal(result4, expected4)
|
||||
if axis == 0:
|
||||
assert_array_equal(y4[15:], y[15:])
|
||||
else:
|
||||
assert_array_equal(y4[:, 15:], y[:, 15:])
|
||||
# Overwrite in a transpose.
|
||||
y5 = y.copy()
|
||||
out5 = y5.T
|
||||
result5 = np.fft.fft(y5, axis=axis, out=out5)
|
||||
assert result5 is out5
|
||||
assert_array_equal(result5, expected1)
|
||||
# Reverse strides.
|
||||
y6 = y.copy()
|
||||
out6 = y6[::-1] if axis == 0 else y6[:, ::-1]
|
||||
result6 = np.fft.fft(y6, axis=axis, out=out6)
|
||||
assert result6 is out6
|
||||
assert_array_equal(result6, expected1)
|
||||
|
||||
def test_fft_bad_out(self):
|
||||
x = np.arange(30.)
|
||||
with pytest.raises(TypeError, match="must be of ArrayType"):
|
||||
np.fft.fft(x, out="")
|
||||
with pytest.raises(ValueError, match="has wrong shape"):
|
||||
np.fft.fft(x, out=np.zeros_like(x).reshape(5, -1))
|
||||
with pytest.raises(TypeError, match="Cannot cast"):
|
||||
np.fft.fft(x, out=np.zeros_like(x, dtype=float))
|
||||
|
||||
@pytest.mark.parametrize('norm', (None, 'backward', 'ortho', 'forward'))
|
||||
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)
|
||||
|
||||
def test_fft2(self):
|
||||
x = random((30, 20)) + 1j * random((30, 20))
|
||||
assert_allclose(np.fft.fft(np.fft.fft(x, axis=1), axis=0),
|
||||
np.fft.fft2(x), atol=1e-6)
|
||||
assert_allclose(np.fft.fft2(x),
|
||||
np.fft.fft2(x, norm="backward"), atol=1e-6)
|
||||
assert_allclose(np.fft.fft2(x) / np.sqrt(30 * 20),
|
||||
np.fft.fft2(x, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(np.fft.fft2(x) / (30. * 20.),
|
||||
np.fft.fft2(x, norm="forward"), atol=1e-6)
|
||||
|
||||
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.fft.ifft2(x, norm="backward"), atol=1e-6)
|
||||
assert_allclose(np.fft.ifft2(x) * np.sqrt(30 * 20),
|
||||
np.fft.ifft2(x, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(np.fft.ifft2(x) * (30. * 20.),
|
||||
np.fft.ifft2(x, norm="forward"), atol=1e-6)
|
||||
|
||||
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.fft.fftn(x, norm="backward"), atol=1e-6)
|
||||
assert_allclose(np.fft.fftn(x) / np.sqrt(30 * 20 * 10),
|
||||
np.fft.fftn(x, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(np.fft.fftn(x) / (30. * 20. * 10.),
|
||||
np.fft.fftn(x, norm="forward"), atol=1e-6)
|
||||
|
||||
def test_ifftn(self):
|
||||
x = random((30, 20, 10)) + 1j * random((30, 20, 10))
|
||||
assert_allclose(
|
||||
np.fft.ifft(np.fft.ifft(np.fft.ifft(x, axis=2), axis=1), axis=0),
|
||||
np.fft.ifftn(x), atol=1e-6)
|
||||
assert_allclose(np.fft.ifftn(x),
|
||||
np.fft.ifftn(x, norm="backward"), atol=1e-6)
|
||||
assert_allclose(np.fft.ifftn(x) * np.sqrt(30 * 20 * 10),
|
||||
np.fft.ifftn(x, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(np.fft.ifftn(x) * (30. * 20. * 10.),
|
||||
np.fft.ifftn(x, norm="forward"), atol=1e-6)
|
||||
|
||||
def test_rfft(self):
|
||||
x = random(30)
|
||||
for n in [x.size, 2 * x.size]:
|
||||
for norm in [None, 'backward', 'ortho', 'forward']:
|
||||
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.fft.rfft(x, n=n, norm="backward"), 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)
|
||||
assert_allclose(
|
||||
np.fft.rfft(x, n=n) / n,
|
||||
np.fft.rfft(x, n=n, norm="forward"), atol=1e-6)
|
||||
|
||||
def test_rfft_even(self):
|
||||
x = np.arange(8)
|
||||
n = 4
|
||||
y = np.fft.rfft(x, n)
|
||||
assert_allclose(y, np.fft.fft(x[:n])[:n // 2 + 1], rtol=1e-14)
|
||||
|
||||
def test_rfft_odd(self):
|
||||
x = np.array([1, 0, 2, 3, -3])
|
||||
y = np.fft.rfft(x)
|
||||
assert_allclose(y, np.fft.fft(x)[:3], rtol=1e-14)
|
||||
|
||||
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="backward"),
|
||||
norm="backward"), atol=1e-6)
|
||||
assert_allclose(x, np.fft.irfft(np.fft.rfft(x, norm="ortho"),
|
||||
norm="ortho"), atol=1e-6)
|
||||
assert_allclose(x, np.fft.irfft(np.fft.rfft(x, norm="forward"),
|
||||
norm="forward"), atol=1e-6)
|
||||
|
||||
def test_rfft2(self):
|
||||
x = random((30, 20))
|
||||
assert_allclose(np.fft.fft2(x)[:, :11], np.fft.rfft2(x), atol=1e-6)
|
||||
assert_allclose(np.fft.rfft2(x),
|
||||
np.fft.rfft2(x, norm="backward"), atol=1e-6)
|
||||
assert_allclose(np.fft.rfft2(x) / np.sqrt(30 * 20),
|
||||
np.fft.rfft2(x, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(np.fft.rfft2(x) / (30. * 20.),
|
||||
np.fft.rfft2(x, norm="forward"), atol=1e-6)
|
||||
|
||||
def test_irfft2(self):
|
||||
x = random((30, 20))
|
||||
assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x)), atol=1e-6)
|
||||
assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x, norm="backward"),
|
||||
norm="backward"), atol=1e-6)
|
||||
assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x, norm="ortho"),
|
||||
norm="ortho"), atol=1e-6)
|
||||
assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x, norm="forward"),
|
||||
norm="forward"), atol=1e-6)
|
||||
|
||||
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.fft.rfftn(x, norm="backward"), atol=1e-6)
|
||||
assert_allclose(np.fft.rfftn(x) / np.sqrt(30 * 20 * 10),
|
||||
np.fft.rfftn(x, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(np.fft.rfftn(x) / (30. * 20. * 10.),
|
||||
np.fft.rfftn(x, norm="forward"), atol=1e-6)
|
||||
# Regression test for gh-27159
|
||||
x = np.ones((2, 3))
|
||||
result = np.fft.rfftn(x, axes=(0, 0, 1), s=(10, 20, 40))
|
||||
assert result.shape == (10, 21)
|
||||
expected = np.fft.fft(np.fft.fft(np.fft.rfft(x, axis=1, n=40),
|
||||
axis=0, n=20), axis=0, n=10)
|
||||
assert expected.shape == (10, 21)
|
||||
assert_allclose(result, expected, atol=1e-6)
|
||||
|
||||
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="backward"),
|
||||
norm="backward"), atol=1e-6)
|
||||
assert_allclose(x, np.fft.irfftn(np.fft.rfftn(x, norm="ortho"),
|
||||
norm="ortho"), atol=1e-6)
|
||||
assert_allclose(x, np.fft.irfftn(np.fft.rfftn(x, norm="forward"),
|
||||
norm="forward"), atol=1e-6)
|
||||
|
||||
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()))
|
||||
assert_allclose(np.fft.fft(x), np.fft.hfft(x_herm), atol=1e-6)
|
||||
assert_allclose(np.fft.hfft(x_herm),
|
||||
np.fft.hfft(x_herm, norm="backward"), atol=1e-6)
|
||||
assert_allclose(np.fft.hfft(x_herm) / np.sqrt(30),
|
||||
np.fft.hfft(x_herm, norm="ortho"), atol=1e-6)
|
||||
assert_allclose(np.fft.hfft(x_herm) / 30.,
|
||||
np.fft.hfft(x_herm, norm="forward"), atol=1e-6)
|
||||
|
||||
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_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm)), atol=1e-6)
|
||||
assert_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm,
|
||||
norm="backward"), norm="backward"), atol=1e-6)
|
||||
assert_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm,
|
||||
norm="ortho"), norm="ortho"), atol=1e-6)
|
||||
assert_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm,
|
||||
norm="forward"), norm="forward"), atol=1e-6)
|
||||
|
||||
@pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
|
||||
np.fft.rfftn, np.fft.irfftn])
|
||||
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)
|
||||
|
||||
@pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
|
||||
np.fft.fft2, np.fft.ifft2])
|
||||
def test_s_negative_1(self, op):
|
||||
x = np.arange(100).reshape(10, 10)
|
||||
# should use the whole input array along the first axis
|
||||
assert op(x, s=(-1, 5), axes=(0, 1)).shape == (10, 5)
|
||||
|
||||
@pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
|
||||
np.fft.rfftn, np.fft.irfftn])
|
||||
def test_s_axes_none(self, op):
|
||||
x = np.arange(100).reshape(10, 10)
|
||||
with pytest.warns(match='`axes` should not be `None` if `s`'):
|
||||
op(x, s=(-1, 5))
|
||||
|
||||
@pytest.mark.parametrize("op", [np.fft.fft2, np.fft.ifft2])
|
||||
def test_s_axes_none_2D(self, op):
|
||||
x = np.arange(100).reshape(10, 10)
|
||||
with pytest.warns(match='`axes` should not be `None` if `s`'):
|
||||
op(x, s=(-1, 5), axes=None)
|
||||
|
||||
@pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
|
||||
np.fft.rfftn, np.fft.irfftn,
|
||||
np.fft.fft2, np.fft.ifft2])
|
||||
def test_s_contains_none(self, op):
|
||||
x = random((30, 20, 10))
|
||||
with pytest.warns(match='array containing `None` values to `s`'):
|
||||
op(x, s=(10, None, 10), axes=(0, 1, 2))
|
||||
|
||||
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 = [(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, 'backward', 'ortho', 'forward']:
|
||||
tmp = forw(x, n=n, norm=norm)
|
||||
tmp = back(tmp, n=n, norm=norm)
|
||||
assert_allclose(x_norm,
|
||||
np.linalg.norm(tmp), atol=1e-6)
|
||||
|
||||
@pytest.mark.parametrize("axes", [(0, 1), (0, 2), None])
|
||||
@pytest.mark.parametrize("dtype", (complex, float))
|
||||
@pytest.mark.parametrize("transpose", (True, False))
|
||||
def test_fftn_out_argument(self, dtype, transpose, axes):
|
||||
def zeros_like(x):
|
||||
if transpose:
|
||||
return np.zeros_like(x.T).T
|
||||
else:
|
||||
return np.zeros_like(x)
|
||||
|
||||
# tests below only test the out parameter
|
||||
if dtype is complex:
|
||||
x = random((10, 5, 6)) + 1j * random((10, 5, 6))
|
||||
fft, ifft = np.fft.fftn, np.fft.ifftn
|
||||
else:
|
||||
x = random((10, 5, 6))
|
||||
fft, ifft = np.fft.rfftn, np.fft.irfftn
|
||||
|
||||
expected = fft(x, axes=axes)
|
||||
out = zeros_like(expected)
|
||||
result = fft(x, out=out, axes=axes)
|
||||
assert result is out
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
expected2 = ifft(expected, axes=axes)
|
||||
out2 = out if dtype is complex else zeros_like(expected2)
|
||||
result2 = ifft(out, out=out2, axes=axes)
|
||||
assert result2 is out2
|
||||
assert_array_equal(result2, expected2)
|
||||
|
||||
@pytest.mark.parametrize("fft", [np.fft.fftn, np.fft.ifftn, np.fft.rfftn])
|
||||
def test_fftn_out_and_s_interaction(self, fft):
|
||||
# With s, shape varies, so generally one cannot pass in out.
|
||||
if fft is np.fft.rfftn:
|
||||
x = random((10, 5, 6))
|
||||
else:
|
||||
x = random((10, 5, 6)) + 1j * random((10, 5, 6))
|
||||
with pytest.raises(ValueError, match="has wrong shape"):
|
||||
fft(x, out=np.zeros_like(x), s=(3, 3, 3), axes=(0, 1, 2))
|
||||
# Except on the first axis done (which is the last of axes).
|
||||
s = (10, 5, 5)
|
||||
expected = fft(x, s=s, axes=(0, 1, 2))
|
||||
out = np.zeros_like(expected)
|
||||
result = fft(x, s=s, axes=(0, 1, 2), out=out)
|
||||
assert result is out
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize("s", [(9, 5, 5), (3, 3, 3)])
|
||||
def test_irfftn_out_and_s_interaction(self, s):
|
||||
# Since for irfftn, the output is real and thus cannot be used for
|
||||
# intermediate steps, it should always work.
|
||||
x = random((9, 5, 6, 2)) + 1j * random((9, 5, 6, 2))
|
||||
expected = np.fft.irfftn(x, s=s, axes=(0, 1, 2))
|
||||
out = np.zeros_like(expected)
|
||||
result = np.fft.irfftn(x, s=s, axes=(0, 1, 2), out=out)
|
||||
assert result is out
|
||||
assert_array_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"dtype",
|
||||
[np.float32, np.float64, np.complex64, np.complex128])
|
||||
@pytest.mark.parametrize("order", ["F", 'non-contiguous'])
|
||||
@pytest.mark.parametrize(
|
||||
"fft",
|
||||
[np.fft.fft, np.fft.fft2, np.fft.fftn,
|
||||
np.fft.ifft, np.fft.ifft2, np.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)
|
||||
# See discussion in pull/14178
|
||||
_tol = 8.0 * np.sqrt(np.log2(X.size)) * np.finfo(X.dtype).eps
|
||||
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_allclose(X_res, Y_res, atol=_tol, rtol=_tol)
|
||||
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_allclose(X_res, Y_res, atol=_tol, rtol=_tol)
|
||||
else:
|
||||
raise ValueError
|
||||
|
||||
|
||||
@pytest.mark.parametrize("order", ["F", "C"])
|
||||
@pytest.mark.parametrize("n", [None, 7, 12])
|
||||
def test_fft_output_order(order, n):
|
||||
rng = np.random.RandomState(42)
|
||||
x = rng.rand(10)
|
||||
x = np.asarray(x, dtype=np.complex64, order=order)
|
||||
res = np.fft.fft(x, n=n)
|
||||
assert res.flags.c_contiguous == x.flags.c_contiguous
|
||||
assert res.flags.f_contiguous == x.flags.f_contiguous
|
||||
|
||||
@pytest.mark.skipif(IS_WASM, reason="Cannot start thread")
|
||||
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) * 1 + 0j
|
||||
self._test_mtsame(np.fft.fft, a)
|
||||
|
||||
def test_ifft(self):
|
||||
a = np.ones(self.input_shape) * 1 + 0j
|
||||
self._test_mtsame(np.fft.ifft, a)
|
||||
|
||||
def test_rfft(self):
|
||||
a = np.ones(self.input_shape)
|
||||
self._test_mtsame(np.fft.rfft, a)
|
||||
|
||||
def test_irfft(self):
|
||||
a = np.ones(self.input_shape) * 1 + 0j
|
||||
self._test_mtsame(np.fft.irfft, a)
|
||||
|
||||
|
||||
def test_irfft_with_n_1_regression():
|
||||
# Regression test for gh-25661
|
||||
x = np.arange(10)
|
||||
np.fft.irfft(x, n=1)
|
||||
np.fft.hfft(x, n=1)
|
||||
np.fft.irfft(np.array([0], complex), n=10)
|
||||
|
||||
|
||||
def test_irfft_with_n_large_regression():
|
||||
# Regression test for gh-25679
|
||||
x = np.arange(5) * (1 + 1j)
|
||||
result = np.fft.hfft(x, n=10)
|
||||
expected = np.array([20., 9.91628173, -11.8819096, 7.1048486,
|
||||
-6.62459848, 4., -3.37540152, -0.16057669,
|
||||
1.8819096, -20.86055364])
|
||||
assert_allclose(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("fft", [
|
||||
np.fft.fft, np.fft.ifft, np.fft.rfft, np.fft.irfft
|
||||
])
|
||||
@pytest.mark.parametrize("data", [
|
||||
np.array([False, True, False]),
|
||||
np.arange(10, dtype=np.uint8),
|
||||
np.arange(5, dtype=np.int16),
|
||||
])
|
||||
def test_fft_with_integer_or_bool_input(data, fft):
|
||||
# Regression test for gh-25819
|
||||
result = fft(data)
|
||||
float_data = data.astype(np.result_type(data, 1.))
|
||||
expected = fft(float_data)
|
||||
assert_array_equal(result, expected)
|
||||
Reference in New Issue
Block a user