Fixed database typo and removed unnecessary class identifier.
This commit is contained in:
parent
00ad49a143
commit
45fb349a7d
5098 changed files with 952558 additions and 85 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
56
venv/Lib/site-packages/scipy/fft/tests/mock_backend.py
Normal file
56
venv/Lib/site-packages/scipy/fft/tests/mock_backend.py
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
import numpy as np
|
||||
|
||||
class _MockFunction:
|
||||
def __init__(self, return_value = None):
|
||||
self.number_calls = 0
|
||||
self.return_value = return_value
|
||||
self.last_args = ([], {})
|
||||
|
||||
def __call__(self, *args, **kwargs):
|
||||
self.number_calls += 1
|
||||
self.last_args = (args, kwargs)
|
||||
return self.return_value
|
||||
|
||||
|
||||
fft = _MockFunction(np.random.random(10))
|
||||
fft2 = _MockFunction(np.random.random(10))
|
||||
fftn = _MockFunction(np.random.random(10))
|
||||
|
||||
ifft = _MockFunction(np.random.random(10))
|
||||
ifft2 = _MockFunction(np.random.random(10))
|
||||
ifftn = _MockFunction(np.random.random(10))
|
||||
|
||||
rfft = _MockFunction(np.random.random(10))
|
||||
rfft2 = _MockFunction(np.random.random(10))
|
||||
rfftn = _MockFunction(np.random.random(10))
|
||||
|
||||
irfft = _MockFunction(np.random.random(10))
|
||||
irfft2 = _MockFunction(np.random.random(10))
|
||||
irfftn = _MockFunction(np.random.random(10))
|
||||
|
||||
hfft = _MockFunction(np.random.random(10))
|
||||
hfft2 = _MockFunction(np.random.random(10))
|
||||
hfftn = _MockFunction(np.random.random(10))
|
||||
|
||||
ihfft = _MockFunction(np.random.random(10))
|
||||
ihfft2 = _MockFunction(np.random.random(10))
|
||||
ihfftn = _MockFunction(np.random.random(10))
|
||||
|
||||
dct = _MockFunction(np.random.random(10))
|
||||
idct = _MockFunction(np.random.random(10))
|
||||
dctn = _MockFunction(np.random.random(10))
|
||||
idctn = _MockFunction(np.random.random(10))
|
||||
|
||||
dst = _MockFunction(np.random.random(10))
|
||||
idst = _MockFunction(np.random.random(10))
|
||||
dstn = _MockFunction(np.random.random(10))
|
||||
idstn = _MockFunction(np.random.random(10))
|
||||
|
||||
|
||||
__ua_domain__ = "numpy.scipy.fft"
|
||||
|
||||
|
||||
def __ua_function__(method, args, kwargs):
|
||||
fn = globals().get(method.__name__)
|
||||
return (fn(*args, **kwargs) if fn is not None
|
||||
else NotImplemented)
|
||||
87
venv/Lib/site-packages/scipy/fft/tests/test_backend.py
Normal file
87
venv/Lib/site-packages/scipy/fft/tests/test_backend.py
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
import numpy as np
|
||||
import scipy.fft
|
||||
from scipy.fft import set_backend
|
||||
from scipy.fft import _pocketfft
|
||||
from scipy.fft.tests import mock_backend
|
||||
|
||||
from numpy.testing import assert_allclose, assert_equal
|
||||
import pytest
|
||||
|
||||
fnames = ('fft', 'fft2', 'fftn',
|
||||
'ifft', 'ifft2', 'ifftn',
|
||||
'rfft', 'rfft2', 'rfftn',
|
||||
'irfft', 'irfft2', 'irfftn',
|
||||
'dct', 'idct', 'dctn', 'idctn',
|
||||
'dst', 'idst', 'dstn', 'idstn')
|
||||
|
||||
np_funcs = (np.fft.fft, np.fft.fft2, np.fft.fftn,
|
||||
np.fft.ifft, np.fft.ifft2, np.fft.ifftn,
|
||||
np.fft.rfft, np.fft.rfft2, np.fft.rfftn,
|
||||
np.fft.irfft, np.fft.irfft2, np.fft.irfftn,
|
||||
np.fft.hfft, _pocketfft.hfft2, _pocketfft.hfftn, # np has no hfftn
|
||||
np.fft.ihfft, _pocketfft.ihfft2, _pocketfft.ihfftn,
|
||||
_pocketfft.dct, _pocketfft.idct, _pocketfft.dctn, _pocketfft.idctn,
|
||||
_pocketfft.dst, _pocketfft.idst, _pocketfft.dstn, _pocketfft.idstn)
|
||||
|
||||
funcs = (scipy.fft.fft, scipy.fft.fft2, scipy.fft.fftn,
|
||||
scipy.fft.ifft, scipy.fft.ifft2, scipy.fft.ifftn,
|
||||
scipy.fft.rfft, scipy.fft.rfft2, scipy.fft.rfftn,
|
||||
scipy.fft.irfft, scipy.fft.irfft2, scipy.fft.irfftn,
|
||||
scipy.fft.hfft, scipy.fft.hfft2, scipy.fft.hfftn,
|
||||
scipy.fft.ihfft, scipy.fft.ihfft2, scipy.fft.ihfftn,
|
||||
scipy.fft.dct, scipy.fft.idct, scipy.fft.dctn, scipy.fft.idctn,
|
||||
scipy.fft.dst, scipy.fft.idst, scipy.fft.dstn, scipy.fft.idstn)
|
||||
|
||||
mocks = (mock_backend.fft, mock_backend.fft2, mock_backend.fftn,
|
||||
mock_backend.ifft, mock_backend.ifft2, mock_backend.ifftn,
|
||||
mock_backend.rfft, mock_backend.rfft2, mock_backend.rfftn,
|
||||
mock_backend.irfft, mock_backend.irfft2, mock_backend.irfftn,
|
||||
mock_backend.hfft, mock_backend.hfft2, mock_backend.hfftn,
|
||||
mock_backend.ihfft, mock_backend.ihfft2, mock_backend.ihfftn,
|
||||
mock_backend.dct, mock_backend.idct, mock_backend.dctn, mock_backend.idctn,
|
||||
mock_backend.dst, mock_backend.idst, mock_backend.dstn, mock_backend.idstn)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("func, np_func, mock", zip(funcs, np_funcs, mocks))
|
||||
def test_backend_call(func, np_func, mock):
|
||||
x = np.arange(20).reshape((10,2))
|
||||
answer = np_func(x)
|
||||
assert_allclose(func(x), answer, atol=1e-10)
|
||||
|
||||
with set_backend(mock_backend, only=True):
|
||||
mock.number_calls = 0
|
||||
y = func(x)
|
||||
assert_equal(y, mock.return_value)
|
||||
assert_equal(mock.number_calls, 1)
|
||||
|
||||
assert_allclose(func(x), answer, atol=1e-10)
|
||||
|
||||
|
||||
plan_funcs = (scipy.fft.fft, scipy.fft.fft2, scipy.fft.fftn,
|
||||
scipy.fft.ifft, scipy.fft.ifft2, scipy.fft.ifftn,
|
||||
scipy.fft.rfft, scipy.fft.rfft2, scipy.fft.rfftn,
|
||||
scipy.fft.irfft, scipy.fft.irfft2, scipy.fft.irfftn,
|
||||
scipy.fft.hfft, scipy.fft.hfft2, scipy.fft.hfftn,
|
||||
scipy.fft.ihfft, scipy.fft.ihfft2, scipy.fft.ihfftn)
|
||||
|
||||
plan_mocks = (mock_backend.fft, mock_backend.fft2, mock_backend.fftn,
|
||||
mock_backend.ifft, mock_backend.ifft2, mock_backend.ifftn,
|
||||
mock_backend.rfft, mock_backend.rfft2, mock_backend.rfftn,
|
||||
mock_backend.irfft, mock_backend.irfft2, mock_backend.irfftn,
|
||||
mock_backend.hfft, mock_backend.hfft2, mock_backend.hfftn,
|
||||
mock_backend.ihfft, mock_backend.ihfft2, mock_backend.ihfftn)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("func, mock", zip(plan_funcs, plan_mocks))
|
||||
def test_backend_plan(func, mock):
|
||||
x = np.arange(20).reshape((10, 2))
|
||||
|
||||
with pytest.raises(NotImplementedError, match='precomputed plan'):
|
||||
func(x, plan='foo')
|
||||
|
||||
with set_backend(mock_backend, only=True):
|
||||
mock.number_calls = 0
|
||||
y = func(x, plan='foo')
|
||||
assert_equal(y, mock.return_value)
|
||||
assert_equal(mock.number_calls, 1)
|
||||
assert_equal(mock.last_args[1]['plan'], 'foo')
|
||||
36
venv/Lib/site-packages/scipy/fft/tests/test_fft_function.py
Normal file
36
venv/Lib/site-packages/scipy/fft/tests/test_fft_function.py
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
import pytest
|
||||
import numpy as np
|
||||
from numpy.testing import assert_allclose
|
||||
|
||||
|
||||
def test_fft_function():
|
||||
# Many NumPy symbols are imported into the scipy namespace, including
|
||||
# numpy.fft.fft as scipy.fft, conflicting with this module (gh-10253)
|
||||
np.random.seed(1234)
|
||||
|
||||
# Callable before scipy.fft is imported
|
||||
import scipy
|
||||
x = np.random.randn(10) + 1j * np.random.randn(10)
|
||||
with pytest.deprecated_call(match=r'1\.5\.0'):
|
||||
X = scipy.fft(x)
|
||||
with pytest.deprecated_call(match=r'2\.0\.0'):
|
||||
y = scipy.ifft(X)
|
||||
assert_allclose(y, x)
|
||||
|
||||
# Callable after scipy.fft is imported
|
||||
import scipy.fft
|
||||
assert_allclose(X, scipy.fft.fft(x))
|
||||
with pytest.deprecated_call(match=r'1\.5\.0'):
|
||||
X = scipy.fft(x)
|
||||
assert_allclose(X, scipy.fft.fft(x))
|
||||
with pytest.deprecated_call(match=r'2\.0\.0'):
|
||||
y = scipy.ifft(X)
|
||||
assert_allclose(y, x)
|
||||
|
||||
# Callable when imported using from
|
||||
from scipy import fft
|
||||
with pytest.deprecated_call(match=r'1\.5\.0'):
|
||||
X = fft(x)
|
||||
with pytest.deprecated_call(match=r'2\.0\.0'):
|
||||
y = scipy.ifft(X)
|
||||
assert_allclose(y, x)
|
||||
297
venv/Lib/site-packages/scipy/fft/tests/test_helper.py
Normal file
297
venv/Lib/site-packages/scipy/fft/tests/test_helper.py
Normal file
|
|
@ -0,0 +1,297 @@
|
|||
from scipy.fft._helper import next_fast_len, _init_nd_shape_and_axes
|
||||
from numpy.testing import assert_equal, assert_array_equal
|
||||
from pytest import raises as assert_raises
|
||||
import pytest
|
||||
import numpy as np
|
||||
import sys
|
||||
|
||||
_5_smooth_numbers = [
|
||||
2, 3, 4, 5, 6, 8, 9, 10,
|
||||
2 * 3 * 5,
|
||||
2**3 * 3**5,
|
||||
2**3 * 3**3 * 5**2,
|
||||
]
|
||||
|
||||
def test_next_fast_len():
|
||||
for n in _5_smooth_numbers:
|
||||
assert_equal(next_fast_len(n), n)
|
||||
|
||||
|
||||
def _assert_n_smooth(x, n):
|
||||
x_orig = x
|
||||
if n < 2:
|
||||
assert False
|
||||
|
||||
while True:
|
||||
q, r = divmod(x, 2)
|
||||
if r != 0:
|
||||
break
|
||||
x = q
|
||||
|
||||
for d in range(3, n+1, 2):
|
||||
while True:
|
||||
q, r = divmod(x, d)
|
||||
if r != 0:
|
||||
break
|
||||
x = q
|
||||
|
||||
assert x == 1, \
|
||||
'x={} is not {}-smooth, remainder={}'.format(x_orig, n, x)
|
||||
|
||||
|
||||
class TestNextFastLen(object):
|
||||
|
||||
def test_next_fast_len(self):
|
||||
np.random.seed(1234)
|
||||
|
||||
def nums():
|
||||
for j in range(1, 1000):
|
||||
yield j
|
||||
yield 2**5 * 3**5 * 4**5 + 1
|
||||
|
||||
for n in nums():
|
||||
m = next_fast_len(n)
|
||||
_assert_n_smooth(m, 11)
|
||||
assert m == next_fast_len(n, False)
|
||||
|
||||
m = next_fast_len(n, True)
|
||||
_assert_n_smooth(m, 5)
|
||||
|
||||
def test_np_integers(self):
|
||||
ITYPES = [np.int16, np.int32, np.int64, np.uint16, np.uint32, np.uint64]
|
||||
for ityp in ITYPES:
|
||||
x = ityp(12345)
|
||||
testN = next_fast_len(x)
|
||||
assert_equal(testN, next_fast_len(int(x)))
|
||||
|
||||
def testnext_fast_len_small(self):
|
||||
hams = {
|
||||
1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 8, 8: 8, 14: 15, 15: 15,
|
||||
16: 16, 17: 18, 1021: 1024, 1536: 1536, 51200000: 51200000
|
||||
}
|
||||
for x, y in hams.items():
|
||||
assert_equal(next_fast_len(x, True), y)
|
||||
|
||||
@pytest.mark.xfail(sys.maxsize < 2**32,
|
||||
reason="Hamming Numbers too large for 32-bit",
|
||||
raises=ValueError, strict=True)
|
||||
def testnext_fast_len_big(self):
|
||||
hams = {
|
||||
510183360: 510183360, 510183360 + 1: 512000000,
|
||||
511000000: 512000000,
|
||||
854296875: 854296875, 854296875 + 1: 859963392,
|
||||
196608000000: 196608000000, 196608000000 + 1: 196830000000,
|
||||
8789062500000: 8789062500000, 8789062500000 + 1: 8796093022208,
|
||||
206391214080000: 206391214080000,
|
||||
206391214080000 + 1: 206624260800000,
|
||||
470184984576000: 470184984576000,
|
||||
470184984576000 + 1: 470715894135000,
|
||||
7222041363087360: 7222041363087360,
|
||||
7222041363087360 + 1: 7230196133913600,
|
||||
# power of 5 5**23
|
||||
11920928955078125: 11920928955078125,
|
||||
11920928955078125 - 1: 11920928955078125,
|
||||
# power of 3 3**34
|
||||
16677181699666569: 16677181699666569,
|
||||
16677181699666569 - 1: 16677181699666569,
|
||||
# power of 2 2**54
|
||||
18014398509481984: 18014398509481984,
|
||||
18014398509481984 - 1: 18014398509481984,
|
||||
# above this, int(ceil(n)) == int(ceil(n+1))
|
||||
19200000000000000: 19200000000000000,
|
||||
19200000000000000 + 1: 19221679687500000,
|
||||
288230376151711744: 288230376151711744,
|
||||
288230376151711744 + 1: 288325195312500000,
|
||||
288325195312500000 - 1: 288325195312500000,
|
||||
288325195312500000: 288325195312500000,
|
||||
288325195312500000 + 1: 288555831593533440,
|
||||
}
|
||||
for x, y in hams.items():
|
||||
assert_equal(next_fast_len(x, True), y)
|
||||
|
||||
|
||||
class Test_init_nd_shape_and_axes(object):
|
||||
|
||||
def test_py_0d_defaults(self):
|
||||
x = np.array(4)
|
||||
shape = None
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([])
|
||||
axes_expected = np.array([])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_np_0d_defaults(self):
|
||||
x = np.array(7.)
|
||||
shape = None
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([])
|
||||
axes_expected = np.array([])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_py_1d_defaults(self):
|
||||
x = np.array([1, 2, 3])
|
||||
shape = None
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([3])
|
||||
axes_expected = np.array([0])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_np_1d_defaults(self):
|
||||
x = np.arange(0, 1, .1)
|
||||
shape = None
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([10])
|
||||
axes_expected = np.array([0])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_py_2d_defaults(self):
|
||||
x = np.array([[1, 2, 3, 4],
|
||||
[5, 6, 7, 8]])
|
||||
shape = None
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([2, 4])
|
||||
axes_expected = np.array([0, 1])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_np_2d_defaults(self):
|
||||
x = np.arange(0, 1, .1).reshape(5, 2)
|
||||
shape = None
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([5, 2])
|
||||
axes_expected = np.array([0, 1])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_np_5d_defaults(self):
|
||||
x = np.zeros([6, 2, 5, 3, 4])
|
||||
shape = None
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([6, 2, 5, 3, 4])
|
||||
axes_expected = np.array([0, 1, 2, 3, 4])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_np_5d_set_shape(self):
|
||||
x = np.zeros([6, 2, 5, 3, 4])
|
||||
shape = [10, -1, -1, 1, 4]
|
||||
axes = None
|
||||
|
||||
shape_expected = np.array([10, 2, 5, 1, 4])
|
||||
axes_expected = np.array([0, 1, 2, 3, 4])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_np_5d_set_axes(self):
|
||||
x = np.zeros([6, 2, 5, 3, 4])
|
||||
shape = None
|
||||
axes = [4, 1, 2]
|
||||
|
||||
shape_expected = np.array([4, 2, 5])
|
||||
axes_expected = np.array([4, 1, 2])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_np_5d_set_shape_axes(self):
|
||||
x = np.zeros([6, 2, 5, 3, 4])
|
||||
shape = [10, -1, 2]
|
||||
axes = [1, 0, 3]
|
||||
|
||||
shape_expected = np.array([10, 6, 2])
|
||||
axes_expected = np.array([1, 0, 3])
|
||||
|
||||
shape_res, axes_res = _init_nd_shape_and_axes(x, shape, axes)
|
||||
|
||||
assert_equal(shape_res, shape_expected)
|
||||
assert_equal(axes_res, axes_expected)
|
||||
|
||||
def test_shape_axes_subset(self):
|
||||
x = np.zeros((2, 3, 4, 5))
|
||||
shape, axes = _init_nd_shape_and_axes(x, shape=(5, 5, 5), axes=None)
|
||||
|
||||
assert_array_equal(shape, [5, 5, 5])
|
||||
assert_array_equal(axes, [1, 2, 3])
|
||||
|
||||
def test_errors(self):
|
||||
x = np.zeros(1)
|
||||
with assert_raises(ValueError, match="axes must be a scalar or "
|
||||
"iterable of integers"):
|
||||
_init_nd_shape_and_axes(x, shape=None, axes=[[1, 2], [3, 4]])
|
||||
|
||||
with assert_raises(ValueError, match="axes must be a scalar or "
|
||||
"iterable of integers"):
|
||||
_init_nd_shape_and_axes(x, shape=None, axes=[1., 2., 3., 4.])
|
||||
|
||||
with assert_raises(ValueError,
|
||||
match="axes exceeds dimensionality of input"):
|
||||
_init_nd_shape_and_axes(x, shape=None, axes=[1])
|
||||
|
||||
with assert_raises(ValueError,
|
||||
match="axes exceeds dimensionality of input"):
|
||||
_init_nd_shape_and_axes(x, shape=None, axes=[-2])
|
||||
|
||||
with assert_raises(ValueError,
|
||||
match="all axes must be unique"):
|
||||
_init_nd_shape_and_axes(x, shape=None, axes=[0, 0])
|
||||
|
||||
with assert_raises(ValueError, match="shape must be a scalar or "
|
||||
"iterable of integers"):
|
||||
_init_nd_shape_and_axes(x, shape=[[1, 2], [3, 4]], axes=None)
|
||||
|
||||
with assert_raises(ValueError, match="shape must be a scalar or "
|
||||
"iterable of integers"):
|
||||
_init_nd_shape_and_axes(x, shape=[1., 2., 3., 4.], axes=None)
|
||||
|
||||
with assert_raises(ValueError,
|
||||
match="when given, axes and shape arguments"
|
||||
" have to be of the same length"):
|
||||
_init_nd_shape_and_axes(np.zeros([1, 1, 1, 1]),
|
||||
shape=[1, 2, 3], axes=[1])
|
||||
|
||||
with assert_raises(ValueError,
|
||||
match="invalid number of data points"
|
||||
r" \(\[0\]\) specified"):
|
||||
_init_nd_shape_and_axes(x, shape=[0], axes=None)
|
||||
|
||||
with assert_raises(ValueError,
|
||||
match="invalid number of data points"
|
||||
r" \(\[-2\]\) specified"):
|
||||
_init_nd_shape_and_axes(x, shape=-2, axes=None)
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
from scipy import fft
|
||||
import numpy as np
|
||||
import pytest
|
||||
from numpy.testing import assert_allclose
|
||||
import multiprocessing
|
||||
import os
|
||||
|
||||
|
||||
@pytest.fixture(scope='module')
|
||||
def x():
|
||||
return np.random.randn(512, 128) # Must be large enough to qualify for mt
|
||||
|
||||
|
||||
@pytest.mark.parametrize("func", [
|
||||
fft.fft, fft.ifft, fft.fft2, fft.ifft2, fft.fftn, fft.ifftn,
|
||||
fft.rfft, fft.irfft, fft.rfft2, fft.irfft2, fft.rfftn, fft.irfftn,
|
||||
fft.hfft, fft.ihfft, fft.hfft2, fft.ihfft2, fft.hfftn, fft.ihfftn,
|
||||
fft.dct, fft.idct, fft.dctn, fft.idctn,
|
||||
fft.dst, fft.idst, fft.dstn, fft.idstn,
|
||||
])
|
||||
@pytest.mark.parametrize("workers", [2, -1])
|
||||
def test_threaded_same(x, func, workers):
|
||||
expected = func(x, workers=1)
|
||||
actual = func(x, workers=workers)
|
||||
assert_allclose(actual, expected)
|
||||
|
||||
|
||||
def _mt_fft(x):
|
||||
return fft.fft(x, workers=2)
|
||||
|
||||
|
||||
def test_mixed_threads_processes(x):
|
||||
# Test that the fft threadpool is safe to use before & after fork
|
||||
|
||||
expect = fft.fft(x, workers=2)
|
||||
|
||||
with multiprocessing.Pool(2) as p:
|
||||
res = p.map(_mt_fft, [x for _ in range(4)])
|
||||
|
||||
for r in res:
|
||||
assert_allclose(r, expect)
|
||||
|
||||
fft.fft(x, workers=2)
|
||||
|
||||
|
||||
def test_invalid_workers(x):
|
||||
cpus = os.cpu_count()
|
||||
|
||||
fft.ifft([1], workers=-cpus)
|
||||
|
||||
with pytest.raises(ValueError, match='workers must not be zero'):
|
||||
fft.fft(x, workers=0)
|
||||
|
||||
with pytest.raises(ValueError, match='workers value out of range'):
|
||||
fft.ifft(x, workers=-cpus-1)
|
||||
|
||||
|
||||
def test_set_get_workers():
|
||||
cpus = os.cpu_count()
|
||||
assert fft.get_workers() == 1
|
||||
with fft.set_workers(4):
|
||||
assert fft.get_workers() == 4
|
||||
|
||||
with fft.set_workers(-1):
|
||||
assert fft.get_workers() == cpus
|
||||
|
||||
assert fft.get_workers() == 4
|
||||
|
||||
assert fft.get_workers() == 1
|
||||
|
||||
with fft.set_workers(-cpus):
|
||||
assert fft.get_workers() == 1
|
||||
|
||||
|
||||
def test_set_workers_invalid():
|
||||
|
||||
with pytest.raises(ValueError, match='workers must not be zero'):
|
||||
with fft.set_workers(0):
|
||||
pass
|
||||
|
||||
with pytest.raises(ValueError, match='workers value out of range'):
|
||||
with fft.set_workers(-os.cpu_count()-1):
|
||||
pass
|
||||
325
venv/Lib/site-packages/scipy/fft/tests/test_numpy.py
Normal file
325
venv/Lib/site-packages/scipy/fft/tests/test_numpy.py
Normal file
|
|
@ -0,0 +1,325 @@
|
|||
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(object):
|
||||
|
||||
def test_fft_n(self):
|
||||
assert_raises(ValueError, fft.fft, [1, 2, 3], 0)
|
||||
|
||||
|
||||
class TestFFT1D(object):
|
||||
|
||||
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)
|
||||
assert_array_almost_equal(fft1(x), fft.fft(x))
|
||||
assert_array_almost_equal(fft1(x) / np.sqrt(30),
|
||||
fft.fft(x, norm="ortho"))
|
||||
|
||||
def test_ifft(self):
|
||||
x = random(30) + 1j*random(30)
|
||||
assert_array_almost_equal(x, fft.ifft(fft.fft(x)))
|
||||
assert_array_almost_equal(
|
||||
x, fft.ifft(fft.fft(x, norm="ortho"), norm="ortho"))
|
||||
|
||||
def test_fft2(self):
|
||||
x = random((30, 20)) + 1j*random((30, 20))
|
||||
assert_array_almost_equal(fft.fft(fft.fft(x, axis=1), axis=0),
|
||||
fft.fft2(x))
|
||||
assert_array_almost_equal(fft.fft2(x) / np.sqrt(30 * 20),
|
||||
fft.fft2(x, norm="ortho"))
|
||||
|
||||
def test_ifft2(self):
|
||||
x = random((30, 20)) + 1j*random((30, 20))
|
||||
assert_array_almost_equal(fft.ifft(fft.ifft(x, axis=1), axis=0),
|
||||
fft.ifft2(x))
|
||||
assert_array_almost_equal(fft.ifft2(x) * np.sqrt(30 * 20),
|
||||
fft.ifft2(x, norm="ortho"))
|
||||
|
||||
def test_fftn(self):
|
||||
x = random((30, 20, 10)) + 1j*random((30, 20, 10))
|
||||
assert_array_almost_equal(
|
||||
fft.fft(fft.fft(fft.fft(x, axis=2), axis=1), axis=0),
|
||||
fft.fftn(x))
|
||||
assert_array_almost_equal(fft.fftn(x) / np.sqrt(30 * 20 * 10),
|
||||
fft.fftn(x, norm="ortho"))
|
||||
|
||||
def test_ifftn(self):
|
||||
x = random((30, 20, 10)) + 1j*random((30, 20, 10))
|
||||
assert_array_almost_equal(
|
||||
fft.ifft(fft.ifft(fft.ifft(x, axis=2), axis=1), axis=0),
|
||||
fft.ifftn(x))
|
||||
assert_array_almost_equal(fft.ifftn(x) * np.sqrt(30 * 20 * 10),
|
||||
fft.ifftn(x, norm="ortho"))
|
||||
|
||||
def test_rfft(self):
|
||||
x = random(30)
|
||||
for n in [x.size, 2*x.size]:
|
||||
for norm in [None, 'ortho']:
|
||||
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)))
|
||||
assert_array_almost_equal(
|
||||
x, fft.irfft(fft.rfft(x, norm="ortho"), norm="ortho"))
|
||||
|
||||
def test_rfft2(self):
|
||||
x = random((30, 20))
|
||||
assert_array_almost_equal(fft.fft2(x)[:, :11], fft.rfft2(x))
|
||||
assert_array_almost_equal(fft.rfft2(x) / np.sqrt(30 * 20),
|
||||
fft.rfft2(x, norm="ortho"))
|
||||
|
||||
def test_irfft2(self):
|
||||
x = random((30, 20))
|
||||
assert_array_almost_equal(x, fft.irfft2(fft.rfft2(x)))
|
||||
assert_array_almost_equal(
|
||||
x, fft.irfft2(fft.rfft2(x, norm="ortho"), norm="ortho"))
|
||||
|
||||
def test_rfftn(self):
|
||||
x = random((30, 20, 10))
|
||||
assert_array_almost_equal(fft.fftn(x)[:, :, :6], fft.rfftn(x))
|
||||
assert_array_almost_equal(fft.rfftn(x) / np.sqrt(30 * 20 * 10),
|
||||
fft.rfftn(x, norm="ortho"))
|
||||
|
||||
def test_irfftn(self):
|
||||
x = random((30, 20, 10))
|
||||
assert_array_almost_equal(x, fft.irfftn(fft.rfftn(x)))
|
||||
assert_array_almost_equal(
|
||||
x, fft.irfftn(fft.rfftn(x, norm="ortho"), norm="ortho"))
|
||||
|
||||
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_array_almost_equal(fft.fft(x), fft.hfft(x_herm))
|
||||
assert_array_almost_equal(fft.hfft(x_herm) / np.sqrt(30),
|
||||
fft.hfft(x_herm, norm="ortho"))
|
||||
|
||||
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)))
|
||||
assert_array_almost_equal(
|
||||
x_herm, fft.ihfft(fft.hfft(x_herm, norm="ortho"),
|
||||
norm="ortho"))
|
||||
|
||||
def test_hfft2(self):
|
||||
x = random((30, 20))
|
||||
assert_array_almost_equal(x, fft.hfft2(fft.ihfft2(x)))
|
||||
assert_array_almost_equal(
|
||||
x, fft.hfft2(fft.ihfft2(x, norm="ortho"), norm="ortho"))
|
||||
|
||||
def test_ihfft2(self):
|
||||
x = random((30, 20))
|
||||
assert_array_almost_equal(fft.ifft2(x)[:, :11], fft.ihfft2(x))
|
||||
assert_array_almost_equal(fft.ihfft2(x) * np.sqrt(30 * 20),
|
||||
fft.ihfft2(x, norm="ortho"))
|
||||
|
||||
def test_hfftn(self):
|
||||
x = random((30, 20, 10))
|
||||
assert_array_almost_equal(x, fft.hfftn(fft.ihfftn(x)))
|
||||
assert_array_almost_equal(
|
||||
x, fft.hfftn(fft.ihfftn(x, norm="ortho"), norm="ortho"))
|
||||
|
||||
def test_ihfftn(self):
|
||||
x = random((30, 20, 10))
|
||||
assert_array_almost_equal(fft.ifftn(x)[:, :, :6], fft.ihfftn(x))
|
||||
assert_array_almost_equal(fft.ihfftn(x) * np.sqrt(30 * 20 * 10),
|
||||
fft.ihfftn(x, norm="ortho"))
|
||||
|
||||
@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 [None, 'ortho']:
|
||||
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(object):
|
||||
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(object):
|
||||
|
||||
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)
|
||||
144
venv/Lib/site-packages/scipy/fft/tests/test_real_transforms.py
Normal file
144
venv/Lib/site-packages/scipy/fft/tests/test_real_transforms.py
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_allclose, assert_array_equal
|
||||
import pytest
|
||||
|
||||
from scipy.fft import dct, idct, dctn, idctn, dst, idst, dstn, idstn
|
||||
import scipy.fft as fft
|
||||
from scipy import fftpack
|
||||
|
||||
# scipy.fft wraps the fftpack versions but with normalized inverse transforms.
|
||||
# So, the forward transforms and definitions are already thoroughly tested in
|
||||
# fftpack/test_real_transforms.py
|
||||
|
||||
|
||||
@pytest.mark.parametrize("forward, backward", [(dct, idct), (dst, idst)])
|
||||
@pytest.mark.parametrize("type", [1, 2, 3, 4])
|
||||
@pytest.mark.parametrize("n", [2, 3, 4, 5, 10, 16])
|
||||
@pytest.mark.parametrize("axis", [0, 1])
|
||||
@pytest.mark.parametrize("norm", [None, 'ortho'])
|
||||
def test_identity_1d(forward, backward, type, n, axis, norm):
|
||||
# Test the identity f^-1(f(x)) == x
|
||||
x = np.random.rand(n, n)
|
||||
|
||||
y = forward(x, type, axis=axis, norm=norm)
|
||||
z = backward(y, type, axis=axis, norm=norm)
|
||||
assert_allclose(z, x)
|
||||
|
||||
pad = [(0, 0)] * 2
|
||||
pad[axis] = (0, 4)
|
||||
|
||||
y2 = np.pad(y, pad, mode='edge')
|
||||
z2 = backward(y2, type, n, axis, norm)
|
||||
assert_allclose(z2, x)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("forward, backward", [(dct, idct), (dst, idst)])
|
||||
@pytest.mark.parametrize("type", [1, 2, 3, 4])
|
||||
@pytest.mark.parametrize("dtype", [np.float16, np.float32, np.float64,
|
||||
np.complex64, np.complex128])
|
||||
@pytest.mark.parametrize("axis", [0, 1])
|
||||
@pytest.mark.parametrize("norm", [None, 'ortho'])
|
||||
@pytest.mark.parametrize("overwrite_x", [True, False])
|
||||
def test_identity_1d_overwrite(forward, backward, type, dtype, axis, norm,
|
||||
overwrite_x):
|
||||
# Test the identity f^-1(f(x)) == x
|
||||
x = np.random.rand(7, 8)
|
||||
x_orig = x.copy()
|
||||
|
||||
y = forward(x, type, axis=axis, norm=norm, overwrite_x=overwrite_x)
|
||||
y_orig = y.copy()
|
||||
z = backward(y, type, axis=axis, norm=norm, overwrite_x=overwrite_x)
|
||||
if not overwrite_x:
|
||||
assert_allclose(z, x, rtol=1e-6, atol=1e-6)
|
||||
assert_array_equal(x, x_orig)
|
||||
assert_array_equal(y, y_orig)
|
||||
else:
|
||||
assert_allclose(z, x_orig, rtol=1e-6, atol=1e-6)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("forward, backward", [(dctn, idctn), (dstn, idstn)])
|
||||
@pytest.mark.parametrize("type", [1, 2, 3, 4])
|
||||
@pytest.mark.parametrize("shape, axes",
|
||||
[
|
||||
((4, 4), 0),
|
||||
((4, 4), 1),
|
||||
((4, 4), None),
|
||||
((4, 4), (0, 1)),
|
||||
((10, 12), None),
|
||||
((10, 12), (0, 1)),
|
||||
((4, 5, 6), None),
|
||||
((4, 5, 6), 1),
|
||||
((4, 5, 6), (0, 2)),
|
||||
])
|
||||
@pytest.mark.parametrize("norm", [None, 'ortho'])
|
||||
def test_identity_nd(forward, backward, type, shape, axes, norm):
|
||||
# Test the identity f^-1(f(x)) == x
|
||||
|
||||
x = np.random.random(shape)
|
||||
|
||||
if axes is not None:
|
||||
shape = np.take(shape, axes)
|
||||
|
||||
y = forward(x, type, axes=axes, norm=norm)
|
||||
z = backward(y, type, axes=axes, norm=norm)
|
||||
assert_allclose(z, x)
|
||||
|
||||
if axes is None:
|
||||
pad = [(0, 4)] * x.ndim
|
||||
elif isinstance(axes, int):
|
||||
pad = [(0, 0)] * x.ndim
|
||||
pad[axes] = (0, 4)
|
||||
else:
|
||||
pad = [(0, 0)] * x.ndim
|
||||
|
||||
for a in axes:
|
||||
pad[a] = (0, 4)
|
||||
|
||||
y2 = np.pad(y, pad, mode='edge')
|
||||
z2 = backward(y2, type, shape, axes, norm)
|
||||
assert_allclose(z2, x)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("forward, backward", [(dctn, idctn), (dstn, idstn)])
|
||||
@pytest.mark.parametrize("type", [1, 2, 3, 4])
|
||||
@pytest.mark.parametrize("shape, axes",
|
||||
[
|
||||
((4, 5), 0),
|
||||
((4, 5), 1),
|
||||
((4, 5), None),
|
||||
])
|
||||
@pytest.mark.parametrize("dtype", [np.float16, np.float32, np.float64,
|
||||
np.complex64, np.complex128])
|
||||
@pytest.mark.parametrize("norm", [None, 'ortho'])
|
||||
@pytest.mark.parametrize("overwrite_x", [False, True])
|
||||
def test_identity_nd_overwrite(forward, backward, type, shape, axes, dtype,
|
||||
norm, overwrite_x):
|
||||
# Test the identity f^-1(f(x)) == x
|
||||
|
||||
x = np.random.random(shape).astype(dtype)
|
||||
x_orig = x.copy()
|
||||
|
||||
if axes is not None:
|
||||
shape = np.take(shape, axes)
|
||||
|
||||
y = forward(x, type, axes=axes, norm=norm)
|
||||
y_orig = y.copy()
|
||||
z = backward(y, type, axes=axes, norm=norm)
|
||||
if overwrite_x:
|
||||
assert_allclose(z, x_orig, rtol=1e-6, atol=1e-6)
|
||||
else:
|
||||
assert_allclose(z, x, rtol=1e-6, atol=1e-6)
|
||||
assert_array_equal(x, x_orig)
|
||||
assert_array_equal(y, y_orig)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("func", ['dct', 'dst', 'dctn', 'dstn'])
|
||||
@pytest.mark.parametrize("type", [1, 2, 3, 4])
|
||||
@pytest.mark.parametrize("norm", [None, 'ortho'])
|
||||
def test_fftpack_equivalience(func, type, norm):
|
||||
x = np.random.rand(8, 16)
|
||||
fft_res = getattr(fft, func)(x, type, norm=norm)
|
||||
fftpack_res = getattr(fftpack, func)(x, type, norm=norm)
|
||||
|
||||
assert_allclose(fft_res, fftpack_res)
|
||||
Loading…
Add table
Add a link
Reference in a new issue