扩展指标

2026-07-09 05:08:16 +08:00
commit 308c46ab9a
537 changed files with 152299 additions and 0 deletions
@@ -0,0 +1,588 @@
+"""Unit tests for ferro_ta.indicators.momentum"""
+
+import numpy as np
+
+from ferro_ta.indicators.momentum import (
+    ADX,
+    ADXR,
+    APO,
+    AROON,
+    AROONOSC,
+    BOP,
+    CCI,
+    CMO,
+    DX,
+    MFI,
+    MINUS_DI,
+    MINUS_DM,
+    MOM,
+    PLUS_DI,
+    PLUS_DM,
+    PPO,
+    ROC,
+    ROCP,
+    ROCR,
+    ROCR100,
+    RSI,
+    STOCH,
+    STOCHF,
+    STOCHRSI,
+    TRIX,
+    ULTOSC,
+    WILLR,
+)
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(7)
+N = 100
+_CLOSE = 100 + np.cumsum(RNG.normal(0, 0.5, N))
+_HIGH = _CLOSE + np.abs(RNG.normal(0, 0.3, N))
+_LOW = _CLOSE - np.abs(RNG.normal(0, 0.3, N))
+_OPEN = _CLOSE + RNG.normal(0, 0.1, N)
+_VOL = RNG.uniform(1000, 5000, N)
+
+SMALL5 = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+SMALL5_H = np.array([12.0, 13.0, 14.0, 15.0, 16.0])
+SMALL5_L = np.array([9.0, 10.0, 11.0, 12.0, 13.0])
+SMALL5_O = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+SMALL5_V = np.array([1000.0, 2000.0, 3000.0, 4000.0, 5000.0])
+
+
+# ---------------------------------------------------------------------------
+# RSI
+# ---------------------------------------------------------------------------
+
+
+class TestRSI:
+    def test_nan_warmup(self):
+        result = RSI(_CLOSE, timeperiod=14)
+        assert np.all(np.isnan(result[:14]))
+
+    def test_range(self):
+        result = RSI(_CLOSE, timeperiod=14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_length(self):
+        assert len(RSI(_CLOSE, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# STOCH
+# ---------------------------------------------------------------------------
+
+
+class TestSTOCH:
+    def test_returns_two_arrays(self):
+        result = STOCH(_HIGH, _LOW, _CLOSE)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_range(self):
+        slowk, slowd = STOCH(_HIGH, _LOW, _CLOSE)
+        for arr in [slowk, slowd]:
+            valid = arr[~np.isnan(arr)]
+            assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_length(self):
+        slowk, slowd = STOCH(_HIGH, _LOW, _CLOSE)
+        assert len(slowk) == len(slowd) == N
+
+
+# ---------------------------------------------------------------------------
+# STOCHF
+# ---------------------------------------------------------------------------
+
+
+class TestSTOCHF:
+    def test_returns_two_arrays(self):
+        result = STOCHF(_HIGH, _LOW, _CLOSE)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_fastk_range(self):
+        fastk, fastd = STOCHF(_HIGH, _LOW, _CLOSE, fastk_period=5, fastd_period=3)
+        valid = fastk[~np.isnan(fastk)]
+        assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_known_values(self):
+        # With identical OHLC, fast %K = 100 * (C - min_low) / (max_high - min_low)
+        # On our SMALL5 data the range is constant so all = 2/6 * 100 ≈ 66.67
+        h5 = np.array([12.0, 13.0, 14.0, 15.0, 16.0])
+        l5 = np.array([9.0, 10.0, 11.0, 12.0, 13.0])
+        c5 = np.array([11.0, 12.0, 13.0, 14.0, 15.0])
+        fastk, fastd = STOCHF(h5, l5, c5, fastk_period=3, fastd_period=2)
+        valid_k = fastk[~np.isnan(fastk)]
+        assert np.all(valid_k >= 0) and np.all(valid_k <= 100)
+
+    def test_length(self):
+        fastk, fastd = STOCHF(_HIGH, _LOW, _CLOSE)
+        assert len(fastk) == len(fastd) == N
+
+
+# ---------------------------------------------------------------------------
+# STOCHRSI
+# ---------------------------------------------------------------------------
+
+
+class TestSTOCHRSI:
+    def test_returns_two_arrays(self):
+        result = STOCHRSI(_CLOSE)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_range(self):
+        fastk, fastd = STOCHRSI(_CLOSE, timeperiod=14)
+        for arr in [fastk, fastd]:
+            valid = arr[~np.isnan(arr)]
+            assert np.all(valid >= -1e-10) and np.all(valid <= 100 + 1e-10)
+
+    def test_length(self):
+        fastk, fastd = STOCHRSI(_CLOSE)
+        assert len(fastk) == N
+
+
+# ---------------------------------------------------------------------------
+# ADX
+# ---------------------------------------------------------------------------
+
+
+class TestADX:
+    def test_nan_warmup(self):
+        result = ADX(_HIGH, _LOW, _CLOSE, timeperiod=14)
+        assert np.all(np.isnan(result[:27]))
+
+    def test_range(self):
+        result = ADX(_HIGH, _LOW, _CLOSE, timeperiod=14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_length(self):
+        assert len(ADX(_HIGH, _LOW, _CLOSE, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# ADXR
+# ---------------------------------------------------------------------------
+
+
+class TestADXR:
+    def test_length(self):
+        assert len(ADXR(_HIGH, _LOW, _CLOSE, 14)) == N
+
+    def test_range(self):
+        result = ADXR(_HIGH, _LOW, _CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0) and np.all(valid <= 100)
+
+
+# ---------------------------------------------------------------------------
+# CCI
+# ---------------------------------------------------------------------------
+
+
+class TestCCI:
+    def test_known_constant_mean_dev(self):
+        # Constant typical price → CCI = 0 after warmup
+        c5 = np.full(10, 12.0)
+        h5 = np.full(10, 13.0)
+        l5 = np.full(10, 11.0)
+        result = CCI(h5, l5, c5, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, 0.0, atol=1e-10)
+
+    def test_length(self):
+        assert len(CCI(_HIGH, _LOW, _CLOSE, 14)) == N
+
+    def test_nan_warmup(self):
+        result = CCI(_HIGH, _LOW, _CLOSE, timeperiod=14)
+        assert np.all(np.isnan(result[:13]))
+
+    def test_simple_rising(self):
+        h = np.array([12.0, 13.0, 14.0, 15.0, 16.0])
+        l = np.array([9.0, 10.0, 11.0, 12.0, 13.0])
+        c = np.array([11.0, 12.0, 13.0, 14.0, 15.0])
+        result = CCI(h, l, c, 3)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, 100.0, atol=1e-8)
+
+
+# ---------------------------------------------------------------------------
+# WILLR
+# ---------------------------------------------------------------------------
+
+
+class TestWILLR:
+    def test_range(self):
+        result = WILLR(_HIGH, _LOW, _CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= -100) and np.all(valid <= 0)
+
+    def test_length(self):
+        assert len(WILLR(_HIGH, _LOW, _CLOSE, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# AROON
+# ---------------------------------------------------------------------------
+
+
+class TestAROON:
+    def test_returns_two_arrays(self):
+        result = AROON(_HIGH, _LOW, 14)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_range(self):
+        aroon_down, aroon_up = AROON(_HIGH, _LOW, 14)
+        for arr in [aroon_down, aroon_up]:
+            valid = arr[~np.isnan(arr)]
+            assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_length(self):
+        aroon_down, aroon_up = AROON(_HIGH, _LOW, 14)
+        assert len(aroon_down) == N
+
+
+# ---------------------------------------------------------------------------
+# AROONOSC
+# ---------------------------------------------------------------------------
+
+
+class TestAROONOSC:
+    def test_known_values(self):
+        h = np.array([12.0, 13.0, 14.0, 15.0, 16.0])
+        l = np.array([9.0, 10.0, 11.0, 12.0, 13.0])
+        result = AROONOSC(h, l, timeperiod=2)
+        valid = result[~np.isnan(result)]
+        # Monotone rising high/low → aroon_up = 100, aroon_down = 0 → osc = 100
+        np.testing.assert_allclose(valid, 100.0, atol=1e-10)
+
+    def test_equals_aroon_diff(self):
+        aroon_down, aroon_up = AROON(_HIGH, _LOW, 14)
+        aroonosc = AROONOSC(_HIGH, _LOW, 14)
+        valid = ~np.isnan(aroon_up) & ~np.isnan(aroon_down) & ~np.isnan(aroonosc)
+        np.testing.assert_allclose(
+            aroonosc[valid],
+            aroon_up[valid] - aroon_down[valid],
+            atol=1e-10,
+        )
+
+    def test_length(self):
+        assert len(AROONOSC(_HIGH, _LOW, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# MFI
+# ---------------------------------------------------------------------------
+
+
+class TestMFI:
+    def test_range(self):
+        result = MFI(_HIGH, _LOW, _CLOSE, _VOL, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_length(self):
+        assert len(MFI(_HIGH, _LOW, _CLOSE, _VOL, 14)) == N
+
+    def test_nan_warmup(self):
+        result = MFI(_HIGH, _LOW, _CLOSE, _VOL, 14)
+        assert np.all(np.isnan(result[:14]))
+
+    def test_constant_price_is_50(self):
+        # When money flow is neither positive nor negative → MFI should be near 50
+        # Use alternating tiny moves around constant so no clear direction
+        c = np.full(20, 100.0)
+        h = np.full(20, 101.0)
+        l = np.full(20, 99.0)
+        v = np.full(20, 1000.0)
+        result = MFI(h, l, c, v, 5)
+        valid = result[~np.isnan(result)]
+        assert len(valid) > 0  # just ensure it runs
+
+
+# ---------------------------------------------------------------------------
+# MOM
+# ---------------------------------------------------------------------------
+
+
+class TestMOM:
+    def test_known_values(self):
+        result = MOM(SMALL5, timeperiod=2)
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        np.testing.assert_allclose(result[2], 2.0, rtol=1e-10)
+        np.testing.assert_allclose(result[3], 2.0, rtol=1e-10)
+
+    def test_length(self):
+        assert len(MOM(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# ROC
+# ---------------------------------------------------------------------------
+
+
+class TestROC:
+    def test_known_values(self):
+        arr = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+        result = ROC(arr, 2)
+        # ROC = ((close - close[n]) / close[n]) * 100
+        np.testing.assert_allclose(result[2], (12 - 10) / 10 * 100, rtol=1e-10)
+
+    def test_length(self):
+        assert len(ROC(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# ROCP
+# ---------------------------------------------------------------------------
+
+
+class TestROCP:
+    def test_known_values(self):
+        arr = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+        result = ROCP(arr, 2)
+        # ROCP = (close - close[n]) / close[n]
+        np.testing.assert_allclose(result[2], (12 - 10) / 10, rtol=1e-10)
+
+    def test_length(self):
+        assert len(ROCP(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# ROCR
+# ---------------------------------------------------------------------------
+
+
+class TestROCR:
+    def test_known_values(self):
+        arr = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+        result = ROCR(arr, 2)
+        # ROCR = close / close[n]
+        np.testing.assert_allclose(result[2], 12 / 10, rtol=1e-10)
+        np.testing.assert_allclose(result[4], 14 / 12, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = ROCR(_CLOSE, 10)
+        assert np.all(np.isnan(result[:10]))
+
+    def test_length(self):
+        assert len(ROCR(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# ROCR100
+# ---------------------------------------------------------------------------
+
+
+class TestROCR100:
+    def test_known_values(self):
+        arr = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+        result = ROCR100(arr, 2)
+        # ROCR100 = (close / close[n]) * 100
+        np.testing.assert_allclose(result[2], 12 / 10 * 100, rtol=1e-10)
+
+    def test_relation_to_rocr(self):
+        rocr = ROCR(_CLOSE, 5)
+        rocr100 = ROCR100(_CLOSE, 5)
+        valid = ~np.isnan(rocr)
+        np.testing.assert_allclose(rocr100[valid], rocr[valid] * 100, rtol=1e-10)
+
+    def test_length(self):
+        assert len(ROCR100(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# CMO
+# ---------------------------------------------------------------------------
+
+
+class TestCMO:
+    def test_range(self):
+        result = CMO(_CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= -100) and np.all(valid <= 100)
+
+    def test_length(self):
+        assert len(CMO(_CLOSE, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# DX
+# ---------------------------------------------------------------------------
+
+
+class TestDX:
+    def test_range(self):
+        result = DX(_HIGH, _LOW, _CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_length(self):
+        assert len(DX(_HIGH, _LOW, _CLOSE, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# MINUS_DI / MINUS_DM
+# ---------------------------------------------------------------------------
+
+
+class TestMINUS:
+    def test_minus_di_range(self):
+        result = MINUS_DI(_HIGH, _LOW, _CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0)
+
+    def test_minus_dm_range(self):
+        result = MINUS_DM(_HIGH, _LOW, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0)
+
+    def test_lengths(self):
+        assert len(MINUS_DI(_HIGH, _LOW, _CLOSE, 14)) == N
+        assert len(MINUS_DM(_HIGH, _LOW, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# PLUS_DI / PLUS_DM
+# ---------------------------------------------------------------------------
+
+
+class TestPLUS:
+    def test_plus_di_range(self):
+        result = PLUS_DI(_HIGH, _LOW, _CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0)
+
+    def test_plus_dm_range(self):
+        result = PLUS_DM(_HIGH, _LOW, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0)
+
+    def test_lengths(self):
+        assert len(PLUS_DI(_HIGH, _LOW, _CLOSE, 14)) == N
+        assert len(PLUS_DM(_HIGH, _LOW, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# PPO
+# ---------------------------------------------------------------------------
+
+
+class TestPPO:
+    def test_returns_three_arrays(self):
+        result = PPO(_CLOSE, fastperiod=12, slowperiod=26)
+        assert isinstance(result, tuple) and len(result) == 3
+
+    def test_histogram_is_diff(self):
+        ppo, signal, hist = PPO(_CLOSE, fastperiod=12, slowperiod=26)
+        valid = ~np.isnan(ppo) & ~np.isnan(signal)
+        np.testing.assert_allclose(hist[valid], ppo[valid] - signal[valid], atol=1e-10)
+
+    def test_length(self):
+        ppo, signal, hist = PPO(_CLOSE)
+        assert len(ppo) == len(signal) == len(hist) == N
+
+    def test_nan_warmup(self):
+        ppo, signal, hist = PPO(_CLOSE, fastperiod=12, slowperiod=26)
+        assert np.any(np.isnan(ppo))
+
+
+# ---------------------------------------------------------------------------
+# APO
+# ---------------------------------------------------------------------------
+
+
+class TestAPO:
+    def test_known_direction(self):
+        # Rising close → fast EMA > slow EMA → APO > 0 after warmup
+        rising = np.linspace(1.0, 100.0, 60)
+        result = APO(rising, fastperiod=5, slowperiod=10)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid > 0)
+
+    def test_length(self):
+        assert len(APO(_CLOSE, 12, 26)) == N
+
+    def test_nan_warmup(self):
+        result = APO(_CLOSE, 12, 26)
+        assert np.any(np.isnan(result))
+
+
+# ---------------------------------------------------------------------------
+# TRIX
+# ---------------------------------------------------------------------------
+
+
+class TestTRIX:
+    def test_length(self):
+        assert len(TRIX(_CLOSE, 10)) == N
+
+    def test_nan_warmup(self):
+        result = TRIX(_CLOSE, timeperiod=5)
+        # TRIX warmup = 3*(tp-1) for triple EMA + 1 for diff
+        assert np.all(np.isnan(result[:12]))
+
+    def test_finite_after_warmup(self):
+        result = TRIX(_CLOSE, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+    def test_rising_series_positive(self):
+        rising = np.linspace(1.0, 200.0, 100)
+        result = TRIX(rising, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        # On monotone rise, rate of change of triple EMA is positive
+        assert np.all(valid > 0)
+
+
+# ---------------------------------------------------------------------------
+# BOP
+# ---------------------------------------------------------------------------
+
+
+class TestBOP:
+    def test_known_values(self):
+        o = np.array([10.0, 11.0])
+        h = np.array([14.0, 15.0])
+        l = np.array([8.0, 9.0])
+        c = np.array([12.0, 13.0])
+        # BOP = (close - open) / (high - low)
+        result = BOP(o, h, l, c)
+        np.testing.assert_allclose(result[0], (12 - 10) / (14 - 8), rtol=1e-10)
+        np.testing.assert_allclose(result[1], (13 - 11) / (15 - 9), rtol=1e-10)
+
+    def test_bearish_is_negative(self):
+        o = np.array([14.0, 14.0])
+        h = np.array([15.0, 15.0])
+        l = np.array([8.0, 8.0])
+        c = np.array([10.0, 10.0])
+        result = BOP(o, h, l, c)
+        assert np.all(result < 0)
+
+    def test_range(self):
+        # BOP = (close - open) / (high - low); can exceed [-1,1] with noisy data
+        result = BOP(_OPEN, _HIGH, _LOW, _CLOSE)
+        assert np.all(np.isfinite(result))
+
+    def test_length(self):
+        assert len(BOP(_OPEN, _HIGH, _LOW, _CLOSE)) == N
+
+
+# ---------------------------------------------------------------------------
+# ULTOSC
+# ---------------------------------------------------------------------------
+
+
+class TestULTOSC:
+    def test_range(self):
+        result = ULTOSC(_HIGH, _LOW, _CLOSE, 7, 14, 28)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0) and np.all(valid <= 100)
+
+    def test_length(self):
+        assert len(ULTOSC(_HIGH, _LOW, _CLOSE, 7, 14, 28)) == N
+
+    def test_nan_warmup(self):
+        result = ULTOSC(_HIGH, _LOW, _CLOSE, 7, 14, 28)
+        assert np.any(np.isnan(result))