sigima 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

sigima/tests/signal/datetime_unit_test.py

@@ -0,0 +1,176 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DateTime support unit tests
+===========================
+
+Unit tests for datetime functionality in SignalObj.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+import numpy as np
+import pytest
+
+from sigima.objects import create_signal
+from sigima.objects.signal.constants import VALID_TIME_UNITS
+from sigima.tests.env import execenv
+
+
+def test_signal_datetime_methods() -> None:
+    """Test SignalObj datetime methods."""
+    execenv.print("Testing SignalObj datetime methods...")
+
+    # Create datetime data
+    base_time = datetime(2025, 10, 6, 10, 0, 0)
+    timestamps = [base_time + timedelta(seconds=i) for i in range(10)]
+    values = np.sin(np.arange(10) * 0.5)
+
+    format_str = "%Y-%m-%d %H:%M:%S"
+
+    # Test different units
+    for unit in VALID_TIME_UNITS:
+        # Create signal with initial data
+        signal = create_signal(
+            "Test Signal", x=np.arange(10, dtype=float), y=values.copy()
+        )
+
+        # Initially should not be datetime
+        assert not signal.is_x_datetime()
+
+        # Set x from datetime
+        signal.set_x_from_datetime(timestamps, unit=unit, format_str=format_str)
+
+        # Check datetime flag
+        assert signal.is_x_datetime()
+        assert signal.metadata["x_datetime"] is True
+        assert signal.xunit == unit
+        assert signal.metadata["x_datetime_format"] == format_str
+
+        # Check x data is float
+        assert isinstance(signal.x, np.ndarray)
+        assert signal.x.dtype in (np.float32, np.float64)
+
+        # Get x as datetime
+        dt_values = signal.get_x_as_datetime()
+        assert isinstance(dt_values, np.ndarray)
+        assert dt_values.dtype == np.dtype("datetime64[ns]")
+
+        # Verify y values are unchanged
+        assert np.allclose(signal.y, values)
+
+    execenv.print("  ✓ SignalObj datetime methods test passed")
+
+
+def test_datetime_with_string_input() -> None:
+    """Test datetime conversion from string input."""
+    execenv.print("Testing datetime conversion from strings...")
+
+    signal = create_signal("String DateTime Test")
+
+    # Create datetime strings
+    date_strings = [
+        "2025-10-06 10:00:00",
+        "2025-10-06 10:00:01",
+        "2025-10-06 10:00:02",
+    ]
+    values = [1.0, 2.0, 3.0]
+
+    # Set from strings
+    signal.set_x_from_datetime(date_strings, unit="s")
+    signal.y = values
+
+    # Verify it worked
+    assert signal.is_x_datetime()
+    assert len(signal.x) == len(date_strings)
+
+    # Get back as datetime
+    dt_values = signal.get_x_as_datetime()
+    assert len(dt_values) == len(date_strings)
+
+    execenv.print("  ✓ String datetime conversion test passed")
+
+
+def test_datetime_copy() -> None:
+    """Test that datetime metadata is preserved when copying signal."""
+    execenv.print("Testing datetime metadata preservation in copy...")
+
+    signal = create_signal("Original")
+    timestamps = [datetime(2025, 10, 6, 10, 0, i) for i in range(5)]
+    signal.set_x_from_datetime(timestamps, unit="ms")
+    signal.y = np.arange(5, dtype=float)
+
+    # Copy signal
+    signal_copy = signal.copy()
+
+    # Verify datetime metadata is preserved
+    assert signal_copy.is_x_datetime()
+    assert signal_copy.xunit == "ms"
+    assert np.array_equal(signal.x, signal_copy.x)
+
+    execenv.print("  ✓ Datetime metadata preservation test passed")
+
+
+def test_datetime_non_datetime_signal() -> None:
+    """Test that non-datetime signals work correctly."""
+    execenv.print("Testing non-datetime signal behavior...")
+
+    signal = create_signal("Regular Signal", x=np.arange(10), y=np.sin(np.arange(10)))
+
+    # Should not be datetime
+    assert not signal.is_x_datetime()
+
+    # get_x_as_datetime should return regular x
+    x_data = signal.get_x_as_datetime()
+    assert np.array_equal(x_data, signal.x)
+
+    execenv.print("  ✓ Non-datetime signal test passed")
+
+
+def test_datetime_invalid_unit() -> None:
+    """Test that invalid units raise appropriate errors."""
+    execenv.print("Testing invalid unit handling...")
+
+    timestamps = [datetime(2025, 10, 6, 10, 0, 0)]
+
+    # Test SignalObj.set_x_from_datetime with invalid unit
+    signal = create_signal("Test")
+    with pytest.raises(ValueError, match="Invalid unit"):
+        signal.set_x_from_datetime(timestamps, unit="invalid")
+
+    execenv.print("  ✓ Invalid unit handling test passed")
+
+
+def test_datetime_arithmetic_operations() -> None:
+    """Test that datetime signals work with arithmetic operations."""
+    execenv.print("Testing datetime signal arithmetic...")
+
+    # Create two signals with datetime x
+    base_time = datetime(2025, 10, 6, 10, 0, 0)
+    timestamps = [base_time + timedelta(seconds=i) for i in range(10)]
+
+    signal1 = create_signal("Signal 1")
+    signal1.set_x_from_datetime(timestamps, unit="s")
+    signal1.y = np.arange(10, dtype=float)
+
+    signal2 = create_signal("Signal 2")
+    signal2.set_x_from_datetime(timestamps, unit="s")
+    signal2.y = np.arange(10, dtype=float) * 2
+
+    # The x data should be identical floats
+    assert np.array_equal(signal1.x, signal2.x)
+
+    # Verify we can do arithmetic on y
+    result_y = signal1.y + signal2.y
+    expected_y = np.arange(10, dtype=float) * 3
+    assert np.allclose(result_y, expected_y)
+
+    execenv.print("  ✓ Datetime signal arithmetic test passed")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

sigima/tests/signal/fft1d_unit_test.py

@@ -0,0 +1,303 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal FFT unit test."""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import scipy.signal as sps
+
+import sigima.objects
+import sigima.params
+import sigima.proc.signal
+import sigima.tests.data
+from sigima.enums import PadLocation1D
+from sigima.tests import guiutils
+from sigima.tests.data import get_test_signal
+from sigima.tests.env import execenv
+from sigima.tests.helpers import check_array_result, check_scalar_result
+from sigima.tools.signal import fourier
+
+
+@pytest.mark.validation
+def test_signal_zero_padding() -> None:
+    """1D FFT zero padding validation test."""
+    s1 = sigima.tests.data.create_periodic_signal(
+        sigima.objects.SignalTypes.COSINE, freq=50.0, size=1000
+    )
+
+    # Validate padding length computation
+    for strategy, expected_length in (
+        ("next_pow2", 24),
+        ("double", 1000),
+        ("triple", 2000),
+    ):
+        param = sigima.params.ZeroPadding1DParam.create(strategy=strategy)
+        param.update_from_obj(s1)
+        assert param.n == expected_length, (
+            f"Wrong length for '{param.strategy}' strategy: {param.n}"
+            f" (expected {expected_length})"
+        )
+
+    # Validate zero padding
+    param = sigima.params.ZeroPadding1DParam.create(strategy="custom", n=250)
+    assert param.n is not None
+    for location in PadLocation1D:
+        execenv.print(f"Validating zero padding with location = {location.value}...")
+        param.location = location
+        param.update_from_obj(s1)
+        s2 = sigima.proc.signal.zero_padding(s1, param)
+        len1 = s1.y.size
+        n = param.n
+        exp_len2 = len1 + n
+        assert s2.y.size == exp_len2, f"Wrong length: {len(s2.y)} (expected {exp_len2})"
+        if location == PadLocation1D.APPEND:
+            dx = s1.x[1] - s1.x[0]
+            expected_x = np.pad(
+                s1.x,
+                (0, n),
+                mode="linear_ramp",
+                end_values=(s1.x[-1] + dx * n,),
+            )
+            check_array_result(f"{location.value}: Check x-data", s2.x, expected_x)
+            check_array_result(
+                f"{location.value}: Check original y-data", s2.y[:len1], s1.y
+            )
+            check_array_result(
+                f"{location.value}: Check padded y-data", s2.y[len1:], np.zeros(n)
+            )
+        elif location == PadLocation1D.PREPEND:
+            dx = s1.x[1] - s1.x[0]
+            expected_x = np.pad(
+                s1.x,
+                (n, 0),
+                mode="linear_ramp",
+                end_values=(s1.x[0] - dx * n,),
+            )
+            check_array_result(f"{location.value}: Check x-data", s2.x, expected_x)
+            check_array_result(
+                f"{location.value}: Check original y-data", s2.y[-len1:], s1.y
+            )
+            check_array_result(
+                f"{location.value}: Check padded y-data", s2.y[:n], np.zeros(n)
+            )
+        elif location == PadLocation1D.BOTH:
+            dx = s1.x[1] - s1.x[0]
+            expected_x = np.pad(
+                s1.x,
+                (n // 2, n - n // 2),
+                mode="linear_ramp",
+                end_values=(
+                    s1.x[0] - dx * (n // 2),
+                    s1.x[-1] + dx * (n - n // 2),
+                ),
+            )
+            check_array_result(f"{location.value}: Check x-data", s2.x, expected_x)
+            check_array_result(
+                f"{location.value}: Check original y-data",
+                s2.y[n // 2 : n // 2 + len1],
+                s1.y,
+            )
+            check_array_result(
+                f"{location.value}: Check padded y-data (before)",
+                s2.y[: n // 2],
+                np.zeros(n // 2),
+            )
+            check_array_result(
+                f"{location.value}: Check padded y-data (after)",
+                s2.y[-(n - n // 2) :],
+                np.zeros(n - n // 2),
+            )
+        execenv.print("OK")
+
+
+@pytest.mark.validation
+def test_signal_fft() -> None:
+    """1D FFT validation test."""
+    freq = 50.0
+    size = 10000
+
+    # See note in function `test_signal_ifft` below.
+    xmin = 0.0
+
+    s1 = sigima.tests.data.create_periodic_signal(
+        sigima.objects.SignalTypes.COSINE, freq=freq, size=size, xmin=xmin
+    )
+    fft = sigima.proc.signal.fft(s1)
+    ifft = sigima.proc.signal.ifft(fft)
+
+    # Check that the inverse FFT reconstructs the original signal.
+    check_array_result("Original and recovered x data", s1.y, ifft.y.real)
+    check_array_result("Original and recovered y data", s1.x, ifft.x.real)
+
+
+@pytest.mark.validation
+def test_signal_ifft() -> None:
+    """1D iFFT validation test.
+
+    Check that the original and reconstructed signals are equal.
+    """
+    param = sigima.objects.CosineParam.create(size=500)
+
+    # *** Note ***
+    #
+    # We set xmin to 0.0 to be able to compare the X data of the original and
+    # reconstructed signals, because the FFT do not preserve the X data (phase is
+    # lost, sampling rate is assumed to be constant), so that comparing the X data
+    # is not meaningful if xmin is different.
+    param.xmin = 0.0
+
+    s1 = sigima.objects.create_signal_from_param(param)
+    assert s1.xydata is not None
+    t1, y1 = s1.xydata
+    for shift in (True, False):
+        f1, sp1 = fourier.fft1d(t1, y1, shift=shift)
+        t2, y2 = fourier.ifft1d(f1, sp1)
+
+        execenv.print(
+            f"Comparing original and recovered signals for `shift={shift}`...",
+            end=" ",
+        )
+        check_array_result("Original and recovered x data", t2, t1, verbose=False)
+        check_array_result("Original and recovered y data", y2, y1, verbose=False)
+        execenv.print("OK")
+
+        guiutils.view_curves_if_gui(
+            [
+                s1,
+                sigima.objects.create_signal("Recovered", t2, y2),
+                sigima.objects.create_signal("Difference", t1, np.abs(y2 - y1)),
+            ]
+        )
+
+
+@pytest.mark.validation
+def test_signal_magnitude_spectrum() -> None:
+    """1D magnitude spectrum validation test."""
+    freq = 50.0
+    size = 10000
+
+    s1 = sigima.tests.data.create_periodic_signal(
+        sigima.objects.SignalTypes.COSINE, freq=freq, size=size
+    )
+    fft = sigima.proc.signal.fft(s1)
+    mag = sigima.proc.signal.magnitude_spectrum(s1)
+
+    # Check that the peak frequencies are correct.
+    ipk1 = np.argmax(mag.y[: size // 2])
+    ipk2 = np.argmax(mag.y[size // 2 :]) + size // 2
+    fpk1 = fft.x[ipk1]
+    fpk2 = fft.x[ipk2]
+    check_scalar_result("Frequency of the first peak", fpk1, -freq, rtol=1e-4)
+    check_scalar_result("Frequency of the second peak", fpk2, freq, rtol=1e-4)
+
+    # Check that magnitude spectrum is symmetric.
+    check_array_result("Symmetry of magnitude spectrum", mag.y[1::], mag.y[-1:0:-1])
+
+    # Check the magnitude of the peaks.
+    exp_mag = size / 2
+    check_scalar_result("Magnitude of the first peak", mag.y[ipk1], exp_mag, rtol=0.05)
+    check_scalar_result("Magnitude of the second peak", mag.y[ipk2], exp_mag, rtol=0.05)
+
+    # Check that the magnitude spectrum is correct.
+    check_array_result("Cosine signal magnitude spectrum X", mag.x, fft.x.real)
+    check_array_result("Cosine signal magnitude spectrum Y", mag.y, np.abs(fft.y))
+
+    guiutils.view_curves_if_gui(
+        [
+            sigima.objects.create_signal("FFT-real", fft.x.real, fft.x.real),
+            sigima.objects.create_signal("FFT-imag", fft.x.real, fft.y.imag),
+            sigima.objects.create_signal("FFT-magnitude", mag.x.real, mag.y),
+        ]
+    )
+
+
+@pytest.mark.validation
+def test_signal_phase_spectrum() -> None:
+    """1D phase spectrum validation test."""
+    freq = 50.0
+    size = 10000
+
+    s1 = sigima.tests.data.create_periodic_signal(
+        sigima.objects.SignalTypes.COSINE, freq=freq, size=size
+    )
+    fft = sigima.proc.signal.fft(s1)
+    phase = sigima.proc.signal.phase_spectrum(s1)
+
+    # Check that the phase spectrum is correct.
+    check_array_result("Cosine signal phase spectrum X", phase.x, fft.x.real)
+    exp_phase = np.rad2deg(np.angle(fft.y))
+    check_array_result("Cosine signal phase spectrum Y", phase.y, exp_phase)
+
+    guiutils.view_curves_if_gui(
+        [
+            sigima.objects.create_signal("FFT-real", fft.x.real, fft.x.real),
+            sigima.objects.create_signal("FFT-imag", fft.x.real, fft.y.imag),
+            sigima.objects.create_signal("Phase", phase.x.real, phase.y),
+        ]
+    )
+
+
+@pytest.mark.validation
+def test_signal_psd() -> None:
+    """1D Power Spectral Density validation test."""
+    freq = 50.0
+    size = 10000
+
+    s1 = sigima.tests.data.create_periodic_signal(
+        sigima.objects.SignalTypes.COSINE, freq=freq, size=size
+    )
+    param = sigima.params.SpectrumParam()
+    for decibel in (False, True):
+        param.decibel = decibel
+        psd = sigima.proc.signal.psd(s1, param)
+
+        # Check that the PSD is correct.
+        exp_x, exp_y = sps.welch(s1.y, fs=1.0 / (s1.x[1] - s1.x[0]))
+        if decibel:
+            exp_y = 10 * np.log10(exp_y)
+
+        fpk1 = psd.x[np.argmax(psd.y)]
+        check_scalar_result("Frequency of the maximum", fpk1, freq, rtol=2e-2)
+
+        check_array_result(f"Cosine signal PSD X (dB={decibel})", psd.x, exp_x)
+        check_array_result(f"Cosine signal PSD Y (dB={decibel})", psd.y, exp_y)
+
+        guiutils.view_curves_if_gui(
+            [
+                sigima.objects.create_signal("PSD", psd.x, psd.y),
+            ]
+        )
+
+
+@pytest.mark.gui
+def test_signal_spectrum() -> None:
+    """Test several FFT-related functions on `dynamic_parameters.txt`."""
+    with guiutils.lazy_qt_app_context(force=True):
+        # pylint: disable=import-outside-toplevel
+        from sigima.tests.vistools import view_curves
+
+        sig = get_test_signal("dynamic_parameters.txt")
+        view_curves([sig])
+        p = sigima.params.SpectrumParam.create(decibel=True)
+        ms = sigima.proc.signal.magnitude_spectrum(sig, p)
+        view_curves([ms], title="Magnitude spectrum")
+        ps = sigima.proc.signal.phase_spectrum(sig)
+        view_curves([ps], title="Phase spectrum")
+        psd = sigima.proc.signal.psd(sig, p)
+        view_curves([psd], title="Power spectral density")
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_signal_zero_padding()
+    test_signal_fft()
+    test_signal_ifft()
+    test_signal_magnitude_spectrum()
+    test_signal_phase_spectrum()
+    test_signal_psd()
+    test_signal_spectrum()