scirs2-python 0.4.3

"""Tests for scirs2 time series module."""

import numpy as np
import pytest
import scirs2


class TestTimeSeries:
    """Test PyTimeSeries class."""

    def test_create_timeseries(self):
        """Test creating a time series."""
        data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        ts = scirs2.PyTimeSeries(data, None)

        assert len(ts) == 5

    def test_describe(self):
        """Test time series describe method."""
        data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        ts = scirs2.PyTimeSeries(data, None)
        stats = ts.describe()

        assert "mean" in stats
        assert "std" in stats
        assert abs(stats["mean"] - 3.0) < 1e-10


class TestDifferencing:
    """Test differencing operations."""

    def test_first_difference(self):
        """Test first-order differencing."""
        data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        ts = scirs2.PyTimeSeries(data, None)

        diff = scirs2.apply_differencing(ts, 1)

        # First difference of arithmetic progression should be constant
        assert len(diff) == 4
        assert np.allclose(diff, [1.0, 1.0, 1.0, 1.0], atol=1e-10)

    def test_second_difference(self):
        """Test second-order differencing."""
        # Quadratic sequence: differences once gives [3, 5, 7, 9]
        # Using period=2 gives lag-2 differences
        data = np.array([1.0, 4.0, 9.0, 16.0, 25.0])
        ts = scirs2.PyTimeSeries(data, None)

        diff = scirs2.apply_differencing(ts, 2)

        # Lag-2 difference: data[i] - data[i-2]
        # Expected: [9-1, 16-4, 25-9] = [8, 12, 16]
        assert len(diff) == 3
        assert np.allclose(diff, [8.0, 12.0, 16.0], atol=1e-10)

    def test_seasonal_difference(self):
        """Test seasonal differencing."""
        # Create seasonal pattern
        data = np.array([1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 1.0, 2.0, 3.0])
        ts = scirs2.PyTimeSeries(data, None)

        # Seasonal difference with period 3
        diff = scirs2.apply_seasonal_differencing(ts, 3)

        # Seasonal differences should be zero for perfect seasonality
        assert len(diff) == 6
        assert np.allclose(diff, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], atol=1e-10)


class TestARIMA:
    """Test ARIMA model."""

    def test_arima_fit(self):
        """Test ARIMA model fitting."""
        # Create simple AR(1) process
        np.random.seed(42)
        n = 100
        data = np.zeros(n)
        data[0] = np.random.randn()
        for i in range(1, n):
            data[i] = 0.5 * data[i-1] + np.random.randn()

        ts = scirs2.PyTimeSeries(data, None)
        arima = scirs2.PyARIMA(1, 0, 0)
        arima.fit(ts)

        # Model should have parameters
        params = arima.get_params()
        assert "p" in params or len(params) > 0

    def test_arima_forecast(self):
        """Test ARIMA forecasting."""
        # Use AR(1) process with noise for more realistic data
        np.random.seed(123)
        n = 50
        data = np.zeros(n)
        data[0] = np.random.randn()
        for i in range(1, n):
            data[i] = 0.7 * data[i-1] + np.random.randn()

        ts = scirs2.PyTimeSeries(data, None)

        arima = scirs2.PyARIMA(1, 0, 0)
        arima.fit(ts)
        forecast = arima.forecast(3)

        # Forecast should return 3 values
        assert len(forecast) == 3


class TestTransformations:
    """Test time series transformations."""

    def test_boxcox_transform(self):
        """Test Box-Cox transformation."""
        # Positive data required for Box-Cox
        data = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
        ts = scirs2.PyTimeSeries(data, None)

        result = scirs2.boxcox_transform(ts, None)

        assert "transformed" in result
        assert "lambda" in result

        transformed = result["transformed"]
        assert len(transformed) == len(data)

    def test_boxcox_inverse(self):
        """Test Box-Cox inverse transformation."""
        data = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
        ts = scirs2.PyTimeSeries(data, None)

        # Transform
        result = scirs2.boxcox_transform(ts, None)
        transformed = result["transformed"]
        lambda_val = result["lambda"]

        # Inverse transform
        recovered = scirs2.boxcox_inverse(np.array(transformed), lambda_val)

        # Should recover original data
        assert np.allclose(data, recovered, atol=1e-6)


class TestStatisticalTests:
    """Test statistical tests for time series."""

    def test_adf_stationary(self):
        """Test ADF test on stationary series."""
        # White noise is stationary
        np.random.seed(42)
        data = np.random.randn(100)
        ts = scirs2.PyTimeSeries(data, None)

        result = scirs2.adf_test(ts, None)

        assert "statistic" in result
        assert "p_value" in result
        # Stationary series should have low p-value
        assert result["p_value"] < 0.1

    def test_adf_nonstationary(self):
        """Test ADF test on non-stationary series."""
        # Strong deterministic trend is non-stationary
        t = np.arange(100, dtype=np.float64)
        data = t * 0.5 + np.random.randn(100) * 0.1
        ts = scirs2.PyTimeSeries(data, None)

        result = scirs2.adf_test(ts, None)

        # Just check that the function returns valid results
        # ADF test behavior can vary, so we just verify the output structure
        assert "p_value" in result
        assert 0.0 <= result["p_value"] <= 1.0


class TestDecomposition:
    """Test time series decomposition."""

    def test_stl_decomposition(self):
        """Test STL decomposition."""
        # Create seasonal data
        n = 100
        t = np.arange(n)
        seasonal = 5 * np.sin(2 * np.pi * t / 12)
        trend = 0.1 * t
        noise = 0.5 * np.random.randn(n)
        data = seasonal + trend + noise

        ts = scirs2.PyTimeSeries(data, None)

        result = scirs2.stl_decomposition(ts, 12)

        assert "trend" in result
        assert "seasonal" in result
        assert "residual" in result


if __name__ == "__main__":
    pytest.main([__file__, "-v"])