Adding idft

xrft/tests/test_xrft.py

@@ -54,16 +54,16 @@ def time_data(request):
         return cftime.num2date(np.arange(0, 10 * 365), units, request.param)
 
 
-class TestDFTImag(object):
-    def test_dft_1d(self, test_data_1d):
+class TestFFTImag(object):
+    def test_fft_1d(self, test_data_1d):
         """Test the discrete Fourier transform function on one-dimensional data."""
 
         da = test_data_1d
         Nx = len(da)
         dx = float(da.x[1] - da.x[0]) if "x" in da.dims else 1
 
         # defaults with no keyword args
-        ft = xrft.dft(da, detrend="constant")
+        ft = xrft.fft(da, detrend="constant")
         # check that the frequency dimension was created properly
         assert ft.dims == ("freq_x",)
         # check that the coords are correct
@@ -81,28 +81,28 @@ def test_dft_1d(self, test_data_1d):
         npt.assert_allclose(ft_data_expected, ft.values, atol=1e-14)
 
         # redo without removing mean
-        ft = xrft.dft(da)
+        ft = xrft.fft(da)
         ft_data_expected = np.fft.fftshift(np.fft.fft(da))
         npt.assert_allclose(ft_data_expected, ft.values)
 
         # redo with detrending linear least-square fit
-        ft = xrft.dft(da, detrend="linear")
+        ft = xrft.fft(da, detrend="linear")
         da_prime = sps.detrend(da.values)
         ft_data_expected = np.fft.fftshift(np.fft.fft(da_prime))
         npt.assert_allclose(ft_data_expected, ft.values, atol=1e-14)
 
         if "x" in da and not da.chunks:
             da["x"].values[-1] *= 2
             with pytest.raises(ValueError):
-                ft = xrft.dft(da)
+                ft = xrft.fft(da)
 
-    def test_dft_1d_time(self, time_data):
+    def test_fft_1d_time(self, time_data):
         """Test the discrete Fourier transform function on timeseries data."""
         time = time_data
         Nt = len(time)
         da = xr.DataArray(np.random.rand(Nt), coords=[time], dims=["time"])
 
-        ft = xrft.dft(da, shift=False)
+        ft = xrft.fft(da, shift=False)
 
         # check that frequencies are correct
         if pd.api.types.is_datetime64_dtype(time):
@@ -112,16 +112,16 @@ def test_dft_1d_time(self, time_data):
         freq_time_expected = np.fft.fftfreq(Nt, dt)
         npt.assert_allclose(ft["freq_time"], freq_time_expected)
 
-    def test_dft_2d(self):
+    def test_fft_2d(self):
         """Test the discrete Fourier transform on 2D data"""
         N = 16
         da = xr.DataArray(
             np.random.rand(N, N), dims=["x", "y"], coords={"x": range(N), "y": range(N)}
         )
-        ft = xrft.dft(da, shift=False)
+        ft = xrft.fft(da, shift=False)
         npt.assert_almost_equal(ft.values, np.fft.fftn(da.values))
 
-        ft = xrft.dft(da, shift=False, window=True, detrend="constant")
+        ft = xrft.fft(da, shift=False, window=True, detrend="constant")
         dim = da.dims
         window = np.hanning(N) * np.hanning(N)[:, np.newaxis]
         da_prime = (da - da.mean(dim=dim)).values
@@ -134,19 +134,19 @@ def test_dft_2d(self):
         )
         assert (xrft.power_spectrum(da, shift=False, density=True) >= 0.0).all()
 
-    def test_dim_dft(self):
+    def test_dim_fft(self):
         N = 16
         da = xr.DataArray(
             np.random.rand(N, N), dims=["x", "y"], coords={"x": range(N), "y": range(N)}
         )
         npt.assert_array_equal(
-            xrft.dft(da, dim="y", shift=False).values,
-            xrft.dft(da, dim=["y"], shift=False).values,
+            xrft.fft(da, dim="y", shift=False).values,
+            xrft.fft(da, dim=["y"], shift=False).values,
         )
-        assert xrft.dft(da, dim="y").dims == ("x", "freq_y")
+        assert xrft.fft(da, dim="y").dims == ("x", "freq_y")
 
     @pytest.mark.parametrize("dask", [False, True])
-    def test_dft_3d_dask(self, dask):
+    def test_fft_3d_dask(self, dask):
         """Test the discrete Fourier transform on 3D dask array data"""
         N = 16
         da = xr.DataArray(
@@ -156,40 +156,40 @@ def test_dft_3d_dask(self, dask):
         )
         if dask:
             da = da.chunk({"time": 1})
-            daft = xrft.dft(da, dim=["x", "y"], shift=False)
+            daft = xrft.fft(da, dim=["x", "y"], shift=False)
             npt.assert_almost_equal(
                 daft.values, np.fft.fftn(da.chunk({"time": 1}).values, axes=[1, 2])
             )
             da = da.chunk({"x": 1})
             with pytest.raises(ValueError):
-                xrft.dft(da, dim=["x"])
+                xrft.fft(da, dim=["x"])
             with pytest.raises(ValueError):
-                xrft.dft(da, dim="x")
+                xrft.fft(da, dim="x")
 
             da = da.chunk({"time": N})
-            daft = xrft.dft(da, dim=["time"], shift=False, detrend="linear")
+            daft = xrft.fft(da, dim=["time"], shift=False, detrend="linear")
             da_prime = sps.detrend(da, axis=0)
             npt.assert_almost_equal(daft.values, np.fft.fftn(da_prime, axes=[0]))
             npt.assert_array_equal(
-                daft.values, xrft.dft(da, dim="time", shift=False, detrend="linear")
+                daft.values, xrft.fft(da, dim="time", shift=False, detrend="linear")
             )
 
     @pytest.mark.skip(reason="3D detrending not implemented")
-    def test_dft_4d(self):
+    def test_fft_4d(self):
         """Test the discrete Fourier transform on 2D data"""
         N = 16
         da = xr.DataArray(
             np.random.rand(N, N, N, N),
             dims=["time", "z", "y", "x"],
             coords={"time": range(N), "z": range(N), "y": range(N), "x": range(N)},
         )
-        ft = xrft.dft(da, shift=False)
+        ft = xrft.fft(da, shift=False)
         npt.assert_almost_equal(ft.values, np.fft.fftn(da.values))
 
         dim = ["time", "y", "x"]
         da_prime = xrft.detrend(da[:, 0], dim)  # cubic detrend over time, y, and x
         npt.assert_almost_equal(
-            xrft.dft(
+            xrft.fft(
                 da[:, 0].drop("z"),
                 dim=dim,
                 shift=False,
@@ -199,8 +199,8 @@ def test_dft_4d(self):
         )
 
 
-class TestDFTReal(object):
-    def test_dft_real_1d(self, test_data_1d):
+class TestfftReal(object):
+    def test_fft_real_1d(self, test_data_1d):
         """
         Test the discrete Fourier transform function on one-dimensional data.
         """
@@ -209,7 +209,7 @@ def test_dft_real_1d(self, test_data_1d):
         dx = float(da.x[1] - da.x[0]) if "x" in da.dims else 1
 
         # defaults with no keyword args
-        ft = xrft.dft(da, real="x", detrend="constant")
+        ft = xrft.fft(da, real="x", detrend="constant")
         # check that the frequency dimension was created properly
         assert ft.dims == ("freq_x",)
         # check that the coords are correct
@@ -227,9 +227,9 @@ def test_dft_real_1d(self, test_data_1d):
         npt.assert_allclose(ft_data_expected, ft.values, atol=1e-14)
 
         with pytest.raises(ValueError):
-            xrft.dft(da, real="y", detrend="constant")
+            xrft.fft(da, real="y", detrend="constant")
 
-    def test_dft_real_2d(self):
+    def test_fft_real_2d(self):
         """
         Test the real discrete Fourier transform function on one-dimensional
         data. Non-trivial because we need to keep only some of the negative
@@ -244,11 +244,11 @@ def test_dft_real_2d(self):
         dx = float(da.x[1] - da.x[0])
         dy = float(da.y[1] - da.y[0])
 
-        daft = xrft.dft(da, real="x")
+        daft = xrft.fft(da, real="x")
         npt.assert_almost_equal(
             daft.values, np.fft.rfftn(da.transpose("y", "x")).transpose()
         )
-        npt.assert_almost_equal(daft.values, xrft.dft(da, dim=["y"], real="x"))
+        npt.assert_almost_equal(daft.values, xrft.fft(da, dim=["y"], real="x"))
 
         actual_freq_x = daft.coords["freq_x"].values
         expected_freq_x = np.fft.rfftfreq(Nx, dx)
@@ -268,20 +268,20 @@ def test_chunks_to_segments():
     )
 
     with pytest.raises(ValueError):
-        xrft.dft(
+        xrft.fft(
             da.chunk(chunks=((20, N, N), (N - 20, N, N))),
             dim=["time"],
             detrend="linear",
             chunks_to_segments=True,
         )
 
-    ft = xrft.dft(
+    ft = xrft.fft(
         da.chunk({"time": 16}), dim=["time"], shift=False, chunks_to_segments=True
     )
     assert ft.dims == ("time_segment", "freq_time", "y", "x")
     data = da.chunk({"time": 16}).data.reshape((2, 16, N, N))
     npt.assert_almost_equal(ft.values, dsar.fft.fftn(data, axes=[1]), decimal=7)
-    ft = xrft.dft(
+    ft = xrft.fft(
         da.chunk({"y": 16, "x": 16}),
         dim=["y", "x"],
         shift=False,
@@ -306,7 +306,7 @@ def test_chunks_to_segments():
         dims=["time", "y", "x"],
         coords={"time": range(N), "y": range(N), "x": range(N)},
     )
-    ft2 = xrft.dft(
+    ft2 = xrft.fft(
         da2.chunk({"y": 16, "x": 16}),
         dim=["y", "x"],
         shift=False,
@@ -326,11 +326,11 @@ def test_chunks_to_segments():
     )
 
 
-def test_dft_nocoords():
+def test_fft_nocoords():
     # Julius' example
     # https://github.com/rabernat/xrft/issues/17
     data = xr.DataArray(np.random.random([20, 30, 100]), dims=["time", "lat", "lon"])
-    dft = xrft.dft(data, dim=["time"])
+    dft = xrft.fft(data, dim=["time"])
     ps = xrft.power_spectrum(data, dim=["time"])
 
 
@@ -367,19 +367,19 @@ def test_power_spectrum(self, dask):
         ps = xrft.power_spectrum(
             da, dim=["y", "x"], window=True, density=False, detrend="constant"
         )
-        daft = xrft.dft(da, dim=["y", "x"], detrend="constant", window=True)
+        daft = xrft.fft(da, dim=["y", "x"], detrend="constant", window=True)
         npt.assert_almost_equal(ps.values, np.real(daft * np.conj(daft)))
         npt.assert_almost_equal(np.ma.masked_invalid(ps).mask.sum(), 0.0)
 
         ps = xrft.power_spectrum(
             da, dim=["y"], real="x", window=True, density=False, detrend="constant"
         )
-        daft = xrft.dft(da, dim=["y"], real="x", detrend="constant", window=True)
+        daft = xrft.fft(da, dim=["y"], real="x", detrend="constant", window=True)
         npt.assert_almost_equal(ps.values, np.real(daft * np.conj(daft)))
 
         ### Normalized
         ps = xrft.power_spectrum(da, dim=["y", "x"], window=True, detrend="constant")
-        daft = xrft.dft(da, dim=["y", "x"], window=True, detrend="constant")
+        daft = xrft.fft(da, dim=["y", "x"], window=True, detrend="constant")
         test = np.real(daft * np.conj(daft)) / N ** 4
         dk = np.diff(np.fft.fftfreq(N, 1.0))[0]
         test /= dk ** 2
@@ -390,7 +390,7 @@ def test_power_spectrum(self, dask):
         ps = xrft.power_spectrum(
             da, dim=["y", "x"], window=True, density=False, detrend="linear"
         )
-        daft = xrft.dft(da, dim=["y", "x"], window=True, detrend="linear")
+        daft = xrft.fft(da, dim=["y", "x"], window=True, detrend="linear")
         npt.assert_almost_equal(ps.values, np.real(daft * np.conj(daft)))
         npt.assert_almost_equal(np.ma.masked_invalid(ps).mask.sum(), 0.0)
 
@@ -421,8 +421,8 @@ def test_cross_spectrum(self, dask):
             da = da.chunk({"time": 1})
             da2 = da2.chunk({"time": 1})
 
-        daft = xrft.dft(da, dim=dim, shift=True, detrend="constant", window=True)
-        daft2 = xrft.dft(da2, dim=dim, shift=True, detrend="constant", window=True)
+        daft = xrft.fft(da, dim=dim, shift=True, detrend="constant", window=True)
+        daft2 = xrft.fft(da2, dim=dim, shift=True, detrend="constant", window=True)
         cs = xrft.cross_spectrum(
             da, da2, dim=dim, window=True, density=False, detrend="constant"
         )
@@ -891,19 +891,19 @@ def test_spacing_tol(test_data_1d):
     da3 = xr.DataArray(np.random.rand(Nx), coords=[x], dims=["x"])
 
     # This shouldn't raise an error
-    xrft.dft(da3, spacing_tol=1e-1)
+    xrft.fft(da3, spacing_tol=1e-1)
     # But this should
     with pytest.raises(ValueError):
-        xrft.dft(da3, spacing_tol=1e-4)
+        xrft.fft(da3, spacing_tol=1e-4)
 
 
 def test_spacing_tol_float_value(test_data_1d):
     da = test_data_1d
     with pytest.raises(TypeError):
-        xrft.dft(da, spacing_tol="string")
+        xrft.fft(da, spacing_tol="string")
 
 
-@pytest.mark.parametrize("func", ("dft", "power_spectrum"))
+@pytest.mark.parametrize("func", ("fft", "power_spectrum"))
 @pytest.mark.parametrize("dim", ["time"])
 def test_keep_coords(sample_data_3d, func, dim):
     """Test whether xrft keeps multi-dim coords from rasm sample data."""
@@ -969,7 +969,9 @@ def test_true_phase():
     f = np.fft.fftfreq(len(x), dx)
     expected = np.fft.fft(np.fft.ifftshift(y)) * np.exp(-1j * 2.0 * np.pi * f * lag)
     expected = xr.DataArray(expected, dims="freq_x", coords={"freq_x": f})
-    output = xrft.dft(s, dim="x", true_phase=True, shift=False, prefix="freq_")
+    output = xrft.dft(
+        s, dim="x", true_phase=True, true_amplitude=False, shift=False, prefix="freq_"
+    )
     xrt.assert_allclose(expected, output)
 
 
@@ -982,8 +984,8 @@ def test_theoretical_matching(rtol=1e-8, atol=1e-3):
     y = np.cos(2.0 * np.pi * f0 * x)
     y[np.abs(x) >= (T / 2.0)] = 0.0
     s = xr.DataArray(y, dims=("x",), coords={"x": x})
-    S = (
-        xrft.dft(s, dim="x", true_phase=True) * dx
+    S = xrft.dft(
+        s, dim="x", true_phase=True, true_amplitude=True
     )  # Fast Fourier Transform of original signal
     f = S.freq_x  # Frequency axis
     TF_s = xr.DataArray(