扩展指标

ferro-ta-main/tests/unit/analysis/test_backtest_v2.py

@@ -0,0 +1,546 @@
+"""
+v1.1.0 backtest feature tests.
+
+Covers:
+- CommissionModel: total_cost, presets, round-trip JSON, save/load
+- Currency: INR/USD formatting, from_code lookup
+- BacktestEngine: initial_capital, commission_model, trailing_stop, benchmark
+- AdvancedBacktestResult: equity_abs, pnl_abs in trade log, summary fields
+- Volatility-target position sizing
+- Benchmark comparison metrics
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+
+import numpy as np
+import pytest
+from ferro_ta._ferro_ta import CommissionModel
+
+from ferro_ta.analysis.backtest import (
+    EUR,
+    GBP,
+    INR,
+    JPY,
+    USD,
+    USDT,
+    BacktestEngine,
+    Currency,
+    format_currency,
+)
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def close_500():
+    """500-bar synthetic close price series."""
+    rng = np.random.default_rng(12345)
+    return np.cumprod(1.0 + rng.standard_normal(500) * 0.01) * 100.0
+
+
+@pytest.fixture
+def ohlcv_500(close_500):
+    close = close_500
+    high = close * 1.005
+    low = close * 0.995
+    open_ = close * 0.999
+    volume = np.full(len(close), 1_000_000.0)
+    return open_, high, low, close, volume
+
+
+# ===========================================================================
+# TestCommissionModel
+# ===========================================================================
+
+
+class TestCommissionModel:
+    def test_zero_model_costs_nothing(self):
+        m = CommissionModel.zero()
+        assert m.total_cost(100_000, 1, True) == 0.0
+        assert m.total_cost(100_000, 1, False) == 0.0
+
+    def test_flat_per_order(self):
+        m = CommissionModel()
+        m.flat_per_order = 20.0
+        assert m.total_cost(100_000, 1, True) == pytest.approx(20.0)
+        assert m.total_cost(100_000, 1, False) == pytest.approx(20.0)
+
+    def test_max_brokerage_cap(self):
+        m = CommissionModel()
+        m.flat_per_order = 0.0
+        m.rate_of_value = 0.001  # 0.1%
+        m.max_brokerage = 20.0
+        # 0.1% of 50_000 = 50, capped at 20
+        assert m.total_cost(50_000, 1, True) == pytest.approx(20.0)
+        # 0.1% of 5_000 = 5, not capped
+        assert m.total_cost(5_000, 1, True) == pytest.approx(5.0)
+
+    def test_stt_buy_side_only(self):
+        m = CommissionModel()
+        m.stt_rate = 0.001
+        m.stt_on_buy = True
+        m.stt_on_sell = False
+        buy_cost = m.total_cost(100_000, 1, True)
+        sell_cost = m.total_cost(100_000, 1, False)
+        assert buy_cost == pytest.approx(100.0)
+        assert sell_cost == pytest.approx(0.0)
+
+    def test_stt_sell_side_only(self):
+        m = CommissionModel()
+        m.stt_rate = 0.00025
+        m.stt_on_buy = False
+        m.stt_on_sell = True
+        buy_cost = m.total_cost(100_000, 1, True)
+        sell_cost = m.total_cost(100_000, 1, False)
+        assert buy_cost == pytest.approx(0.0)
+        assert sell_cost == pytest.approx(25.0)
+
+    def test_gst_on_brokerage_exchange_not_stt(self):
+        m = CommissionModel()
+        m.flat_per_order = 20.0
+        m.exchange_charges_rate = 0.0001
+        m.gst_rate = 0.18
+        m.stt_rate = 0.001
+        m.stt_on_sell = True
+        # GST = 0.18 * (20 + 0.0001 * 100_000) = 0.18 * 30 = 5.4
+        # STT = 100 (sell side)
+        total = m.total_cost(100_000, 1, False)
+        expected_gst = 0.18 * (20.0 + 0.0001 * 100_000)
+        assert total == pytest.approx(20.0 + 100.0 + 0.0001 * 100_000 + expected_gst)
+
+    def test_stamp_duty_buy_only(self):
+        m = CommissionModel()
+        m.stamp_duty_rate = 0.00015
+        buy_cost = m.total_cost(100_000, 1, True)
+        sell_cost = m.total_cost(100_000, 1, False)
+        assert buy_cost == pytest.approx(15.0)
+        assert sell_cost == pytest.approx(0.0)
+
+    def test_per_lot_charge(self):
+        m = CommissionModel()
+        m.per_lot = 2.0
+        # 5 lots
+        assert m.total_cost(50_000, 5, True) == pytest.approx(10.0)
+
+    def test_cost_fraction(self):
+        m = CommissionModel()
+        m.flat_per_order = 20.0
+        frac = m.cost_fraction(100_000, 1, True, 100_000.0)
+        assert frac == pytest.approx(20.0 / 100_000.0)
+
+    def test_cost_fraction_zero_capital(self):
+        m = CommissionModel()
+        m.flat_per_order = 20.0
+        assert m.cost_fraction(100_000, 1, True, 0.0) == 0.0
+
+    def test_proportional_preset(self):
+        m = CommissionModel.proportional(0.001)
+        assert m.total_cost(100_000, 1, True) == pytest.approx(100.0)
+        assert m.gst_rate == 0.0
+
+    def test_repr_contains_key_fields(self):
+        m = CommissionModel.equity_delivery_india()
+        r = repr(m)
+        assert "CommissionModel" in r
+        assert "lot_size" in r
+
+
+class TestCommissionPresets:
+    def test_equity_delivery_india_smoke(self):
+        m = CommissionModel.equity_delivery_india()
+        # Buy ₹1L trade: brokerage cap ₹20, STT ₹100 (both sides)
+        cost = m.total_cost(100_000, 1, True)
+        assert cost > 0.0
+        assert cost < 500.0  # sanity upper bound
+        # Brokerage should be capped at ₹20
+        assert m.flat_per_order == 0.0
+        assert m.max_brokerage == pytest.approx(20.0)
+        assert m.stt_on_buy is True
+        assert m.stt_on_sell is True
+
+    def test_equity_intraday_india_smoke(self):
+        m = CommissionModel.equity_intraday_india()
+        cost_buy = m.total_cost(100_000, 1, True)
+        cost_sell = m.total_cost(100_000, 1, False)
+        # STT only on sell side for intraday
+        assert m.stt_on_buy is False
+        assert m.stt_on_sell is True
+        assert cost_sell > cost_buy  # sell has more cost (STT)
+
+    def test_futures_india_smoke(self):
+        m = CommissionModel.futures_india()
+        assert m.flat_per_order == pytest.approx(20.0)
+        assert m.stt_on_buy is False
+        assert m.stt_on_sell is True
+        assert m.lot_size == pytest.approx(25.0)
+
+    def test_options_india_smoke(self):
+        m = CommissionModel.options_india()
+        assert m.flat_per_order == pytest.approx(20.0)
+        assert m.stt_rate == pytest.approx(0.0015)
+        assert m.lot_size == pytest.approx(25.0)
+
+
+class TestCommissionFix:
+    """The old 'commission_per_trade=20.0' bug would subtract ₹20 from 1.0-normalized
+    equity — a 2000% error. The new model correctly computes 0.02% fraction."""
+
+    def test_flat_20_on_1L_capital_is_tiny_fraction(self):
+        m = CommissionModel()
+        m.flat_per_order = 20.0
+        frac = m.cost_fraction(100_000, 1, True, 100_000.0)
+        # ₹20 / ₹100_000 = 0.02%
+        assert frac == pytest.approx(20.0 / 100_000.0, rel=1e-6)
+        assert frac < 0.01  # definitely not 2000%
+
+    def test_commission_reduces_equity_vs_no_commission(self):
+        rng = np.random.default_rng(99)
+        close = np.cumprod(1.0 + rng.standard_normal(200) * 0.01) * 100.0
+        m = CommissionModel.equity_intraday_india()
+        r_comm = (
+            BacktestEngine()
+            .with_commission_model(m)
+            .with_initial_capital(100_000)
+            .run(close, "sma_crossover")
+        )
+        r_none = (
+            BacktestEngine().with_initial_capital(100_000).run(close, "sma_crossover")
+        )
+        # Commission should reduce final equity (or keep equal if zero trades)
+        assert r_comm.final_equity <= r_none.final_equity
+
+
+class TestCommissionSaveLoad:
+    def test_to_json_from_json_round_trip(self):
+        m = CommissionModel.equity_delivery_india()
+        j = m.to_json()
+        m2 = CommissionModel.from_json(j)
+        assert m == m2
+        assert m2.stt_rate == pytest.approx(m.stt_rate)
+        assert m2.lot_size == pytest.approx(m.lot_size)
+        assert m2.gst_rate == pytest.approx(m.gst_rate)
+
+    def test_save_load_round_trip(self):
+        m = CommissionModel.futures_india()
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            path = f.name
+        try:
+            m.save(path)
+            assert os.path.exists(path)
+            m2 = CommissionModel.load(path)
+            assert m == m2
+        finally:
+            os.unlink(path)
+
+    def test_from_json_invalid_raises(self):
+        with pytest.raises(Exception):
+            CommissionModel.from_json("{invalid json")
+
+    def test_load_missing_file_raises(self):
+        with pytest.raises(Exception):
+            CommissionModel.load("/nonexistent/path/commission.json")
+
+
+# ===========================================================================
+# TestCurrency
+# ===========================================================================
+
+
+class TestCurrency:
+    def test_inr_lakh_grouping(self):
+        assert INR.format(123456.78) == "₹1,23,456.78"
+        assert INR.format(1000000.0) == "₹10,00,000.00"
+        assert INR.format(10000000.0) == "₹1,00,00,000.00"
+        assert INR.format(100.0) == "₹100.00"
+        assert INR.format(1234.5) == "₹1,234.50"
+
+    def test_inr_negative(self):
+        result = INR.format(-5000.0)
+        assert result.startswith("-₹")
+        assert "5,000.00" in result
+
+    def test_usd_standard_grouping(self):
+        assert USD.format(1234567.89) == "$1,234,567.89"
+        assert USD.format(0.5) == "$0.50"
+        assert USD.format(1000.0) == "$1,000.00"
+
+    def test_jpy_no_decimals(self):
+        result = JPY.format(1000000.0)
+        assert result == "¥1,000,000"
+
+    def test_eur_format(self):
+        assert "€" in EUR.format(100.0)
+
+    def test_gbp_format(self):
+        assert "£" in GBP.format(100.0)
+
+    def test_usdt_format(self):
+        assert "₮" in USDT.format(100.0)
+
+    def test_format_currency_helper(self):
+        assert format_currency(123456.78) == "₹1,23,456.78"
+        assert format_currency(1000.0, USD) == "$1,000.00"
+
+    def test_currency_immutable(self):
+        with pytest.raises(AttributeError):
+            INR.code = "USD"  # type: ignore[misc]
+
+    def test_currency_equality(self):
+        c1 = Currency.from_code("INR")
+        assert c1 == INR
+        assert INR != USD
+
+    def test_currency_hash_usable_in_dict(self):
+        d = {INR: 100_000, USD: 100}
+        assert d[INR] == 100_000
+
+
+# ===========================================================================
+# TestInitialCapital
+# ===========================================================================
+
+
+class TestInitialCapital:
+    def test_equity_abs_shape(self, close_500):
+        result = (
+            BacktestEngine()
+            .with_initial_capital(200_000)
+            .run(close_500, "sma_crossover")
+        )
+        assert result.equity_abs.shape == result.equity.shape
+
+    def test_equity_abs_is_equity_times_capital(self, close_500):
+        capital = 150_000.0
+        result = (
+            BacktestEngine()
+            .with_initial_capital(capital)
+            .run(close_500, "sma_crossover")
+        )
+        np.testing.assert_allclose(result.equity_abs, result.equity * capital)
+
+    def test_summary_contains_capital_fields(self, close_500):
+        capital = 100_000.0
+        result = (
+            BacktestEngine()
+            .with_initial_capital(capital)
+            .run(close_500, "sma_crossover")
+        )
+        s = result.summary()
+        assert "initial_capital" in s
+        assert "final_capital" in s
+        assert "absolute_pnl" in s
+        assert s["initial_capital"] == pytest.approx(capital)
+        assert s["final_capital"] == pytest.approx(result.equity_abs[-1])
+        assert s["absolute_pnl"] == pytest.approx(s["final_capital"] - capital)
+
+    def test_pnl_abs_in_trade_log(self, close_500, ohlcv_500):
+        open_, high, low, close, _ = ohlcv_500
+        capital = 100_000.0
+        result = (
+            BacktestEngine()
+            .with_initial_capital(capital)
+            .with_ohlcv(high=high, low=low, open_=open_)
+            .run(close, "sma_crossover")
+        )
+        if result.trades is not None and len(result.trades) > 0:
+            assert "pnl_abs" in result.trades.columns
+            np.testing.assert_allclose(
+                result.trades["pnl_abs"].values,
+                result.trades["pnl_pct"].values * capital,
+            )
+
+
+class TestINRRepr:
+    def test_repr_shows_inr_symbol(self, close_500):
+        result = (
+            BacktestEngine()
+            .with_currency(INR)
+            .with_initial_capital(100_000)
+            .run(close_500, "sma_crossover")
+        )
+        r = repr(result)
+        assert "₹" in r
+
+    def test_currency_code_in_summary(self, close_500):
+        result = (
+            BacktestEngine()
+            .with_currency("USD")
+            .with_initial_capital(10_000)
+            .run(close_500, "sma_crossover")
+        )
+        s = result.summary()
+        assert s["currency"] == "USD"
+
+    def test_unknown_currency_raises(self):
+        with pytest.raises(Exception, match="Unknown currency"):
+            BacktestEngine().with_currency("XYZ")
+
+
+# ===========================================================================
+# TestVolatilityTargetSizing
+# ===========================================================================
+
+
+class TestVolatilityTargetSizing:
+    def test_vol_target_runs_without_error(self, close_500):
+        result = (
+            BacktestEngine()
+            .with_position_sizing("volatility_target", target_vol=0.10)
+            .run(close_500, "sma_crossover")
+        )
+        assert len(result.equity) == len(close_500)
+        assert np.isfinite(result.final_equity)
+
+    def test_vol_target_signals_are_scaled(self, close_500):
+        # With very low target vol the strategy should have fewer active positions
+        result_low = (
+            BacktestEngine()
+            .with_position_sizing("volatility_target", target_vol=0.01)
+            .run(close_500, "sma_crossover")
+        )
+        result_high = (
+            BacktestEngine()
+            .with_position_sizing("volatility_target", target_vol=1.0)
+            .run(close_500, "sma_crossover")
+        )
+        # Lower vol target → lower absolute position sizes → lower annualised vol
+        low_std = float(np.nanstd(result_low.strategy_returns))
+        high_std = float(np.nanstd(result_high.strategy_returns))
+        assert low_std <= high_std or np.isclose(low_std, high_std, rtol=0.5)
+
+
+# ===========================================================================
+# TestBenchmark
+# ===========================================================================
+
+
+class TestBenchmark:
+    def test_benchmark_metrics_present(self, close_500):
+        rng = np.random.default_rng(77)
+        benchmark = np.cumprod(1.0 + rng.standard_normal(500) * 0.008) * 100.0
+        result = (
+            BacktestEngine().with_benchmark(benchmark).run(close_500, "sma_crossover")
+        )
+        s = result.summary()
+        assert "alpha" in s
+        assert "beta" in s
+        assert "tracking_error" in s
+        assert "information_ratio" in s
+        assert "benchmark_cagr" in s
+
+    def test_identical_strategy_benchmark_has_low_tracking_error(self, close_500):
+        # When strategy returns = benchmark returns, tracking error ≈ 0
+        # Use the equity as its own benchmark
+        result = (
+            BacktestEngine().with_benchmark(close_500).run(close_500, "sma_crossover")
+        )
+        m = result.metrics
+        # Beta should be finite
+        assert np.isfinite(m.get("beta", float("nan")))
+
+    def test_benchmark_wrong_length_ignored(self, close_500):
+        short_bench = close_500[:100]
+        # Should not raise — benchmark mismatch is silently ignored
+        result = (
+            BacktestEngine().with_benchmark(short_bench).run(close_500, "sma_crossover")
+        )
+        # alpha should NOT appear (length mismatch)
+        assert "alpha" not in result.metrics
+
+
+# ===========================================================================
+# TestTrailingStop
+# ===========================================================================
+
+
+class TestTrailingStop:
+    def test_trailing_stop_runs(self, ohlcv_500, close_500):
+        open_, high, low, close, _ = ohlcv_500
+        result = (
+            BacktestEngine()
+            .with_ohlcv(high=high, low=low, open_=open_)
+            .with_trailing_stop(0.02)
+            .run(close, "sma_crossover")
+        )
+        assert len(result.equity) == len(close)
+        assert np.isfinite(result.final_equity)
+
+    def test_trailing_stop_reduces_losses_on_downtrend(self):
+        """Trailing stop should exit longs earlier on a falling market."""
+        # Construct a clear downtrend after initial rise
+        prices = np.concatenate(
+            [
+                np.linspace(100, 120, 50),  # rise (signal stays long)
+                np.linspace(120, 60, 150),  # sharp fall
+            ]
+        )
+        high = prices * 1.002
+        low = prices * 0.998
+        open_ = prices * 0.999
+
+        result_trail = (
+            BacktestEngine()
+            .with_ohlcv(high=high, low=low, open_=open_)
+            .with_trailing_stop(0.03)
+            .run(prices, "sma_crossover")
+        )
+        result_no_trail = (
+            BacktestEngine()
+            .with_ohlcv(high=high, low=low, open_=open_)
+            .run(prices, "sma_crossover")
+        )
+        # Trailing stop should yield better (or equal) max drawdown
+        dd_trail = result_trail.metrics.get("max_drawdown", 0.0)
+        dd_no_trail = result_no_trail.metrics.get("max_drawdown", 0.0)
+        # max_drawdown is negative; higher value = smaller drawdown
+        assert dd_trail >= dd_no_trail - 0.05  # allow 5% tolerance
+
+
+# ===========================================================================
+# TestBacktestEngineChaining
+# ===========================================================================
+
+
+class TestBacktestEngineChaining:
+    def test_full_chain_runs(self, close_500, ohlcv_500):
+        open_, high, low, close, _ = ohlcv_500
+        rng = np.random.default_rng(42)
+        benchmark = np.cumprod(1.0 + rng.standard_normal(500) * 0.008) * 100.0
+
+        result = (
+            BacktestEngine()
+            .with_currency("INR")
+            .with_initial_capital(100_000)
+            .with_commission_model(CommissionModel.equity_intraday_india())
+            .with_trailing_stop(0.02)
+            .with_benchmark(benchmark)
+            .with_ohlcv(high=high, low=low, open_=open_)
+            .run(close, "sma_crossover")
+        )
+        assert len(result.equity) == len(close)
+        assert result.currency == INR
+        assert result.initial_capital == pytest.approx(100_000.0)
+        assert np.isfinite(result.final_equity)
+
+        s = result.summary()
+        assert s["currency"] == "INR"
+        assert "alpha" in s  # benchmark was set
+
+    def test_to_equity_dataframe(self, close_500):
+        result = (
+            BacktestEngine()
+            .with_initial_capital(50_000)
+            .run(close_500, "sma_crossover")
+        )
+        df = result.to_equity_dataframe()
+        assert "equity" in df.columns
+        assert "equity_abs" in df.columns
+        assert "strategy_returns" in df.columns
+        assert "drawdown" in df.columns
+        assert len(df) == len(close_500)
+        np.testing.assert_allclose(df["equity_abs"].values, result.equity_abs)

ferro-ta-main/tests/unit/conftest.py

@@ -0,0 +1,7 @@
+"""
+Unit test conftest — inherits shared fixtures from tests/conftest.py.
+
+pytest automatically loads parent conftest.py files, so all fixtures
+defined in tests/conftest.py (ohlcv_500, ohlcv_100, ohlcv_real) are
+available here without any explicit import.
+"""

ferro-ta-main/tests/unit/helpers.py

@@ -0,0 +1,159 @@
+"""Shared test helpers for ferro_ta unit tests.
+
+This module consolidates common assertion patterns and data-generation
+utilities that are duplicated across multiple test files.  Importing
+from here keeps individual test modules DRY and makes it easier to
+update assertion logic in one place.
+
+Usage
+-----
+    from tests.unit.helpers import (
+        nan_count, finite, assert_nan_warmup, assert_output_length,
+        assert_finite_values, assert_range, make_ohlcv,
+    )
+
+Note: Each test file that already has inline helpers continues to work
+unchanged.  These helpers are provided for *new* tests and for gradual
+consolidation of existing ones.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+# ---------------------------------------------------------------------------
+# Array inspection helpers
+# ---------------------------------------------------------------------------
+
+
+def nan_count(arr: np.ndarray) -> int:
+    """Return the number of NaN entries in *arr*.
+
+    Equivalent to the ``_nan_count`` functions duplicated in:
+    - tests/unit/test_ferro_ta.py
+    - tests/integration/test_vs_talib.py
+    - tests/integration/test_vs_pandas_ta.py
+    """
+    return int(np.sum(np.isnan(arr)))
+
+
+def finite(arr: np.ndarray) -> np.ndarray:
+    """Return only the finite (non-NaN) elements of *arr*.
+
+    Equivalent to the ``_finite`` helpers in:
+    - tests/unit/test_ferro_ta.py
+    - tests/unit/streaming/test_streaming.py
+    """
+    return arr[~np.isnan(arr)]
+
+
+# ---------------------------------------------------------------------------
+# Common assertion helpers
+# ---------------------------------------------------------------------------
+
+
+def assert_output_length(result: np.ndarray, expected_length: int) -> None:
+    """Assert the indicator output has the expected length.
+
+    This pattern (``assert len(result) == len(PRICES)``) appears 82+ times
+    across the test suite.
+    """
+    assert len(result) == expected_length, (
+        f"Expected output length {expected_length}, got {len(result)}"
+    )
+
+
+def assert_nan_warmup(result: np.ndarray, warmup: int) -> None:
+    """Assert that the first *warmup* values are NaN and that at least
+    one value after the warmup period is finite.
+
+    This pattern (``assert np.all(np.isnan(result[:N]))``) appears 36+
+    times in indicator tests.
+    """
+    assert np.all(np.isnan(result[:warmup])), (
+        f"Expected first {warmup} values to be NaN"
+    )
+    if len(result) > warmup:
+        assert np.any(np.isfinite(result[warmup:])), (
+            f"Expected at least one finite value after warmup index {warmup}"
+        )
+
+
+def assert_finite_values(arr: np.ndarray) -> None:
+    """Assert that *all* non-NaN values are finite (not +/-inf).
+
+    The pattern ``np.all(np.isfinite(arr[~np.isnan(arr)]))`` appears
+    60+ times across the test suite.
+    """
+    valid = arr[~np.isnan(arr)]
+    assert np.all(np.isfinite(valid)), "Found non-finite (inf) values in output"
+
+
+def assert_range(
+    arr: np.ndarray,
+    lo: float = 0.0,
+    hi: float = 100.0,
+    *,
+    ignore_nan: bool = True,
+) -> None:
+    """Assert every (non-NaN) value in *arr* falls within [lo, hi].
+
+    The ``valid >= 0 and valid <= 100`` pattern appears 10+ times for
+    oscillator-type indicators (RSI, WILLR, CMO, etc.).
+    """
+    values = arr[~np.isnan(arr)] if ignore_nan else arr
+    assert np.all(values >= lo), f"Found value below {lo}: {values.min()}"
+    assert np.all(values <= hi), f"Found value above {hi}: {values.max()}"
+
+
+def assert_close(
+    actual: np.ndarray,
+    expected: np.ndarray,
+    *,
+    rtol: float = 1e-6,
+    atol: float = 0.0,
+    ignore_nan: bool = True,
+) -> None:
+    """Assert element-wise closeness, optionally skipping NaN positions.
+
+    Thin wrapper around ``np.testing.assert_allclose`` that mirrors the
+    NaN-stripping pattern seen in integration tests.
+    """
+    if ignore_nan:
+        mask = ~(np.isnan(actual) | np.isnan(expected))
+        actual = actual[mask]
+        expected = expected[mask]
+    np.testing.assert_allclose(actual, expected, rtol=rtol, atol=atol)
+
+
+# ---------------------------------------------------------------------------
+# Data generation helpers
+# ---------------------------------------------------------------------------
+
+
+def make_ohlcv(
+    n: int = 100,
+    seed: int = 42,
+    base_price: float = 100.0,
+) -> dict[str, np.ndarray]:
+    """Generate reproducible synthetic OHLCV data.
+
+    This pattern is duplicated across many test files with slight
+    variations (different seeds, base prices, spread logic).  Using
+    this helper ensures consistent generation logic.
+
+    Returns a dict with keys: close, high, low, open, volume.
+    """
+    rng = np.random.default_rng(seed)
+    close = base_price + 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)
+    volume = rng.uniform(1000, 5000, n)
+    return {
+        "close": close,
+        "high": high,
+        "low": low,
+        "open": open_,
+        "volume": volume,
+    }

ferro-ta-main/tests/unit/indicators/test_cycle.py

@@ -0,0 +1,183 @@
+"""Unit tests for ferro_ta.indicators.cycle"""
+
+import numpy as np
+
+from ferro_ta.indicators.cycle import (
+    HT_DCPERIOD,
+    HT_DCPHASE,
+    HT_PHASOR,
+    HT_SINE,
+    HT_TRENDLINE,
+    HT_TRENDMODE,
+)
+
+# ---------------------------------------------------------------------------
+# Shared fixtures — cycle indicators need at least ~64 bars for valid output
+# ---------------------------------------------------------------------------
+
+N = 200
+t = np.linspace(0, 10 * np.pi, N)
+SINE_CLOSE = 100 + 10 * np.sin(t)  # clean sine wave
+
+
+def _warmup_end(arr):
+    """Return index of first non-NaN value (or N if all NaN)."""
+    valid = np.where(~np.isnan(arr.astype(float)))[0]
+    return valid[0] if len(valid) else N
+
+
+# ---------------------------------------------------------------------------
+# HT_DCPERIOD
+# ---------------------------------------------------------------------------
+
+
+class TestHT_DCPERIOD:
+    def test_length(self):
+        result = HT_DCPERIOD(SINE_CLOSE)
+        assert len(result) == N
+
+    def test_nan_warmup(self):
+        result = HT_DCPERIOD(SINE_CLOSE)
+        w = _warmup_end(result)
+        assert w > 0
+        assert np.all(np.isnan(result[:w]))
+
+    def test_valid_finite(self):
+        result = HT_DCPERIOD(SINE_CLOSE)
+        w = _warmup_end(result)
+        assert np.all(np.isfinite(result[w:]))
+
+    def test_sine_period_reasonable(self):
+        # Our sine has period = 2*pi in t; with N=200 and t in [0,10*pi]
+        # the true period in samples = 200 / (10*pi / (2*pi)) = 200/5 = 40
+        result = HT_DCPERIOD(SINE_CLOSE)
+        valid = result[~np.isnan(result)]
+        # HT_DCPERIOD should detect a period in a reasonable range [6, 100]
+        assert np.any((valid > 6) & (valid < 100))
+
+
+# ---------------------------------------------------------------------------
+# HT_DCPHASE
+# ---------------------------------------------------------------------------
+
+
+class TestHT_DCPHASE:
+    def test_length(self):
+        assert len(HT_DCPHASE(SINE_CLOSE)) == N
+
+    def test_nan_warmup(self):
+        result = HT_DCPHASE(SINE_CLOSE)
+        w = _warmup_end(result)
+        assert w > 0
+
+    def test_valid_finite(self):
+        result = HT_DCPHASE(SINE_CLOSE)
+        w = _warmup_end(result)
+        assert np.all(np.isfinite(result[w:]))
+
+
+# ---------------------------------------------------------------------------
+# HT_PHASOR
+# ---------------------------------------------------------------------------
+
+
+class TestHT_PHASOR:
+    def test_returns_two_arrays(self):
+        result = HT_PHASOR(SINE_CLOSE)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_length(self):
+        inphase, quadrature = HT_PHASOR(SINE_CLOSE)
+        assert len(inphase) == len(quadrature) == N
+
+    def test_nan_warmup(self):
+        inphase, quadrature = HT_PHASOR(SINE_CLOSE)
+        w = _warmup_end(inphase)
+        assert w > 0
+
+    def test_valid_finite(self):
+        inphase, quadrature = HT_PHASOR(SINE_CLOSE)
+        wi = _warmup_end(inphase)
+        wq = _warmup_end(quadrature)
+        assert np.all(np.isfinite(inphase[wi:]))
+        assert np.all(np.isfinite(quadrature[wq:]))
+
+
+# ---------------------------------------------------------------------------
+# HT_SINE
+# ---------------------------------------------------------------------------
+
+
+class TestHT_SINE:
+    def test_returns_two_arrays(self):
+        result = HT_SINE(SINE_CLOSE)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_length(self):
+        sine, leadsine = HT_SINE(SINE_CLOSE)
+        assert len(sine) == len(leadsine) == N
+
+    def test_nan_warmup(self):
+        sine, leadsine = HT_SINE(SINE_CLOSE)
+        w = _warmup_end(sine)
+        assert w > 0
+
+    def test_valid_finite(self):
+        sine, leadsine = HT_SINE(SINE_CLOSE)
+        ws = _warmup_end(sine)
+        wl = _warmup_end(leadsine)
+        assert np.all(np.isfinite(sine[ws:]))
+        assert np.all(np.isfinite(leadsine[wl:]))
+
+    def test_values_in_sine_range(self):
+        # Sine values should be in [-1, 1] roughly
+        sine, leadsine = HT_SINE(SINE_CLOSE)
+        valid = sine[~np.isnan(sine)]
+        assert np.all(valid >= -1.5) and np.all(valid <= 1.5)
+
+
+# ---------------------------------------------------------------------------
+# HT_TRENDLINE
+# ---------------------------------------------------------------------------
+
+
+class TestHT_TRENDLINE:
+    def test_length(self):
+        assert len(HT_TRENDLINE(SINE_CLOSE)) == N
+
+    def test_nan_warmup(self):
+        result = HT_TRENDLINE(SINE_CLOSE)
+        w = _warmup_end(result)
+        assert w > 0
+
+    def test_valid_finite(self):
+        result = HT_TRENDLINE(SINE_CLOSE)
+        w = _warmup_end(result)
+        assert np.all(np.isfinite(result[w:]))
+
+    def test_smooth_trendline(self):
+        # Trendline should be smoother than raw close
+        result = HT_TRENDLINE(SINE_CLOSE)
+        w = _warmup_end(result)
+        raw_std = np.std(np.diff(SINE_CLOSE[w:]))
+        trend_std = np.std(np.diff(result[w:]))
+        assert trend_std < raw_std
+
+
+# ---------------------------------------------------------------------------
+# HT_TRENDMODE
+# ---------------------------------------------------------------------------
+
+
+class TestHT_TRENDMODE:
+    def test_length(self):
+        assert len(HT_TRENDMODE(SINE_CLOSE)) == N
+
+    def test_values_binary(self):
+        result = HT_TRENDMODE(SINE_CLOSE)
+        assert np.all(np.isin(result, [0, 1]))
+
+    def test_nan_warmup_as_zero(self):
+        # HT_TRENDMODE returns integers (no NaN); warmup bars should be 0
+        result = HT_TRENDMODE(SINE_CLOSE)
+        assert np.all(np.isfinite(result.astype(float)))

ferro-ta-main/tests/unit/indicators/test_extended.py

@@ -0,0 +1,292 @@
+"""Unit tests for ferro_ta.indicators.extended"""
+
+import numpy as np
+
+from ferro_ta.indicators.extended import (
+    CHANDELIER_EXIT,
+    CHOPPINESS_INDEX,
+    DONCHIAN,
+    HULL_MA,
+    ICHIMOKU,
+    KELTNER_CHANNELS,
+    PIVOT_POINTS,
+    SUPERTREND,
+    VWAP,
+    VWMA,
+)
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(99)
+N = 200
+_C = 100 + np.cumsum(RNG.normal(0, 0.5, N))
+_H = _C + np.abs(RNG.normal(0, 0.3, N))
+_L = _C - np.abs(RNG.normal(0, 0.3, N))
+_O = _C + RNG.normal(0, 0.1, N)
+_VOL = RNG.uniform(1000, 5000, N)
+
+
+# ---------------------------------------------------------------------------
+# VWAP
+# ---------------------------------------------------------------------------
+
+
+class TestVWAP:
+    def test_length(self):
+        result = VWAP(_H, _L, _C, _VOL)
+        assert len(result) == N
+
+    def test_no_nan(self):
+        result = VWAP(_H, _L, _C, _VOL)
+        assert np.all(np.isfinite(result))
+
+    def test_positive(self):
+        result = VWAP(_H, _L, _C, _VOL)
+        assert np.all(result > 0)
+
+    def test_windowed(self):
+        result = VWAP(_H, _L, _C, _VOL, timeperiod=20)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+
+# ---------------------------------------------------------------------------
+# SUPERTREND
+# ---------------------------------------------------------------------------
+
+
+class TestSUPERTREND:
+    def test_returns_two_arrays(self):
+        result = SUPERTREND(_H, _L, _C)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_length(self):
+        trend, direction = SUPERTREND(_H, _L, _C)
+        assert len(trend) == len(direction) == N
+
+    def test_direction_binary(self):
+        trend, direction = SUPERTREND(_H, _L, _C)
+        valid = direction[~np.isnan(direction.astype(float))]
+        assert np.all(np.isin(valid, [-1, 0, 1]))
+
+    def test_nan_warmup(self):
+        trend, direction = SUPERTREND(_H, _L, _C, timeperiod=7)
+        assert np.any(np.isnan(trend))
+
+
+# ---------------------------------------------------------------------------
+# ICHIMOKU
+# ---------------------------------------------------------------------------
+
+
+class TestICHIMOKU:
+    def test_returns_five_arrays(self):
+        result = ICHIMOKU(_H, _L, _C)
+        assert isinstance(result, tuple) and len(result) == 5
+
+    def test_length(self):
+        result = ICHIMOKU(_H, _L, _C)
+        for arr in result:
+            assert len(arr) == N
+
+    def test_tenkan_warmup(self):
+        tenkan, kijun, senkou_a, senkou_b, chikou = ICHIMOKU(
+            _H, _L, _C, tenkan_period=9
+        )
+        assert np.all(np.isnan(tenkan[:8]))
+
+    def test_finite_after_warmup(self):
+        tenkan, kijun, senkou_a, senkou_b, chikou = ICHIMOKU(_H, _L, _C)
+        for arr in [tenkan, kijun]:
+            valid = arr[~np.isnan(arr)]
+            assert np.all(np.isfinite(valid))
+
+
+# ---------------------------------------------------------------------------
+# DONCHIAN
+# ---------------------------------------------------------------------------
+
+
+class TestDONCHIAN:
+    def test_returns_three_arrays(self):
+        result = DONCHIAN(_H, _L)
+        assert isinstance(result, tuple) and len(result) == 3
+
+    def test_length(self):
+        upper, middle, lower = DONCHIAN(_H, _L)
+        assert len(upper) == len(middle) == len(lower) == N
+
+    def test_upper_ge_lower(self):
+        upper, middle, lower = DONCHIAN(_H, _L)
+        valid = ~np.isnan(upper) & ~np.isnan(lower)
+        assert np.all(upper[valid] >= lower[valid])
+
+    def test_middle_is_average(self):
+        upper, middle, lower = DONCHIAN(_H, _L)
+        valid = ~np.isnan(upper) & ~np.isnan(lower) & ~np.isnan(middle)
+        np.testing.assert_allclose(
+            middle[valid],
+            (upper[valid] + lower[valid]) / 2.0,
+            rtol=1e-10,
+        )
+
+    def test_nan_warmup(self):
+        upper, middle, lower = DONCHIAN(_H, _L, timeperiod=20)
+        assert np.all(np.isnan(upper[:19]))
+
+
+# ---------------------------------------------------------------------------
+# PIVOT_POINTS
+# ---------------------------------------------------------------------------
+
+
+class TestPIVOT_POINTS:
+    def test_returns_five_arrays(self):
+        result = PIVOT_POINTS(_H, _L, _C)
+        assert isinstance(result, tuple) and len(result) == 5
+
+    def test_length(self):
+        result = PIVOT_POINTS(_H, _L, _C)
+        for arr in result:
+            assert len(arr) == N
+
+    def test_classic_pivot_formula(self):
+        # PP = (H + L + C) / 3
+        pp, r1, s1, r2, s2 = PIVOT_POINTS(_H, _L, _C, method="classic")
+        valid = ~np.isnan(pp)
+        expected_pp = (_H[:-1] + _L[:-1] + _C[:-1]) / 3.0
+        np.testing.assert_allclose(pp[valid], expected_pp[valid[1:]], rtol=1e-6)
+
+    def test_first_is_nan(self):
+        pp, r1, s1, r2, s2 = PIVOT_POINTS(_H, _L, _C)
+        assert np.isnan(pp[0])
+
+
+# ---------------------------------------------------------------------------
+# KELTNER_CHANNELS
+# ---------------------------------------------------------------------------
+
+
+class TestKELTNER_CHANNELS:
+    def test_returns_three_arrays(self):
+        result = KELTNER_CHANNELS(_H, _L, _C)
+        assert isinstance(result, tuple) and len(result) == 3
+
+    def test_length(self):
+        upper, middle, lower = KELTNER_CHANNELS(_H, _L, _C)
+        assert len(upper) == len(middle) == len(lower) == N
+
+    def test_upper_gt_lower(self):
+        upper, middle, lower = KELTNER_CHANNELS(_H, _L, _C)
+        valid = ~np.isnan(upper) & ~np.isnan(lower)
+        assert np.all(upper[valid] > lower[valid])
+
+    def test_nan_warmup(self):
+        upper, middle, lower = KELTNER_CHANNELS(_H, _L, _C, timeperiod=20)
+        assert np.all(np.isnan(upper[:19]))
+
+
+# ---------------------------------------------------------------------------
+# HULL_MA
+# ---------------------------------------------------------------------------
+
+
+class TestHULL_MA:
+    def test_length(self):
+        assert len(HULL_MA(_C, timeperiod=16)) == N
+
+    def test_nan_warmup(self):
+        result = HULL_MA(_C, timeperiod=16)
+        assert np.all(np.isnan(result[:18]))
+
+    def test_finite_after_warmup(self):
+        result = HULL_MA(_C, timeperiod=16)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+    def test_tracks_trend(self):
+        rising = np.linspace(10.0, 200.0, 200)
+        result = HULL_MA(rising, timeperiod=16)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.diff(valid) > 0)
+
+
+# ---------------------------------------------------------------------------
+# CHANDELIER_EXIT
+# ---------------------------------------------------------------------------
+
+
+class TestCHANDELIER_EXIT:
+    def test_returns_two_arrays(self):
+        result = CHANDELIER_EXIT(_H, _L, _C)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_length(self):
+        long_stop, short_stop = CHANDELIER_EXIT(_H, _L, _C)
+        assert len(long_stop) == len(short_stop) == N
+
+    def test_nan_warmup(self):
+        long_stop, short_stop = CHANDELIER_EXIT(_H, _L, _C, timeperiod=22)
+        assert np.all(np.isnan(long_stop[:21]))
+
+    def test_finite_after_warmup(self):
+        long_stop, short_stop = CHANDELIER_EXIT(_H, _L, _C, timeperiod=22)
+        for arr in [long_stop, short_stop]:
+            valid = arr[~np.isnan(arr)]
+            assert np.all(np.isfinite(valid))
+
+
+# ---------------------------------------------------------------------------
+# VWMA
+# ---------------------------------------------------------------------------
+
+
+class TestVWMA:
+    def test_length(self):
+        assert len(VWMA(_C, _VOL, timeperiod=20)) == N
+
+    def test_nan_warmup(self):
+        result = VWMA(_C, _VOL, timeperiod=20)
+        assert np.all(np.isnan(result[:19]))
+
+    def test_finite_after_warmup(self):
+        result = VWMA(_C, _VOL, timeperiod=20)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+    def test_constant_volume_equals_sma(self):
+        # When all volumes are equal, VWMA = SMA
+        vol = np.ones(N) * 1000.0
+        vwma = VWMA(_C, vol, timeperiod=20)
+        from ferro_ta.indicators.overlap import SMA
+
+        sma = SMA(_C, timeperiod=20)
+        valid = ~np.isnan(vwma) & ~np.isnan(sma)
+        np.testing.assert_allclose(vwma[valid], sma[valid], rtol=1e-8)
+
+
+# ---------------------------------------------------------------------------
+# CHOPPINESS_INDEX
+# ---------------------------------------------------------------------------
+
+
+class TestCHOPPINESS_INDEX:
+    def test_length(self):
+        assert len(CHOPPINESS_INDEX(_H, _L, _C, timeperiod=14)) == N
+
+    def test_nan_warmup(self):
+        result = CHOPPINESS_INDEX(_H, _L, _C, timeperiod=14)
+        assert np.all(np.isnan(result[:14]))
+
+    def test_range(self):
+        # Choppiness index is bounded between 0 and 100
+        result = CHOPPINESS_INDEX(_H, _L, _C, timeperiod=14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid > 0) and np.all(valid < 200)
+
+    def test_finite_after_warmup(self):
+        result = CHOPPINESS_INDEX(_H, _L, _C, timeperiod=14)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))

ferro-ta-main/tests/unit/indicators/test_math_ops.py

@@ -0,0 +1,313 @@
+"""Unit tests for ferro_ta.indicators.math_ops"""
+
+import numpy as np
+
+from ferro_ta.indicators.math_ops import (
+    ACOS,
+    ADD,
+    ASIN,
+    ATAN,
+    CEIL,
+    COS,
+    COSH,
+    DIV,
+    EXP,
+    FLOOR,
+    LN,
+    LOG10,
+    MAX,
+    MAXINDEX,
+    MIN,
+    MININDEX,
+    MULT,
+    SIN,
+    SINH,
+    SQRT,
+    SUB,
+    SUM,
+    TAN,
+    TANH,
+)
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+A3 = np.array([1.0, 2.0, 3.0])
+B3 = np.array([4.0, 5.0, 6.0])
+TRIG = np.array([0.0, np.pi / 6, np.pi / 4, np.pi / 3, np.pi / 2])
+UNIT = np.array([0.0, 0.25, 0.5, 0.75, 1.0])  # values in [0,1] for ASIN/ACOS
+
+RNG = np.random.default_rng(17)
+N = 100
+_ARR = 1.0 + RNG.random(N) * 9.0  # positive values in (1, 10]
+
+
+# ---------------------------------------------------------------------------
+# ADD
+# ---------------------------------------------------------------------------
+
+
+class TestADD:
+    def test_known_values(self):
+        result = ADD(A3, B3)
+        np.testing.assert_allclose(result, [5.0, 7.0, 9.0], rtol=1e-10)
+
+    def test_commutative(self):
+        np.testing.assert_allclose(ADD(A3, B3), ADD(B3, A3), rtol=1e-10)
+
+    def test_length(self):
+        assert len(ADD(_ARR, _ARR)) == N
+
+
+# ---------------------------------------------------------------------------
+# SUB
+# ---------------------------------------------------------------------------
+
+
+class TestSUB:
+    def test_known_values(self):
+        result = SUB(B3, A3)
+        np.testing.assert_allclose(result, [3.0, 3.0, 3.0], rtol=1e-10)
+
+    def test_length(self):
+        assert len(SUB(_ARR, _ARR)) == N
+
+
+# ---------------------------------------------------------------------------
+# MULT
+# ---------------------------------------------------------------------------
+
+
+class TestMULT:
+    def test_known_values(self):
+        result = MULT(A3, B3)
+        np.testing.assert_allclose(result, [4.0, 10.0, 18.0], rtol=1e-10)
+
+    def test_commutative(self):
+        np.testing.assert_allclose(MULT(A3, B3), MULT(B3, A3), rtol=1e-10)
+
+    def test_length(self):
+        assert len(MULT(_ARR, _ARR)) == N
+
+
+# ---------------------------------------------------------------------------
+# DIV
+# ---------------------------------------------------------------------------
+
+
+class TestDIV:
+    def test_known_values(self):
+        result = DIV(B3, A3)
+        np.testing.assert_allclose(result, [4.0, 2.5, 2.0], rtol=1e-10)
+
+    def test_self_division_is_one(self):
+        np.testing.assert_allclose(DIV(_ARR, _ARR), np.ones(N), rtol=1e-10)
+
+    def test_length(self):
+        assert len(DIV(_ARR, _ARR)) == N
+
+
+# ---------------------------------------------------------------------------
+# SUM
+# ---------------------------------------------------------------------------
+
+
+class TestSUM:
+    def test_known_values(self):
+        arr = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        result = SUM(arr, timeperiod=3)
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        np.testing.assert_allclose(result[2], 6.0, rtol=1e-10)
+        np.testing.assert_allclose(result[4], 12.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = SUM(_ARR, timeperiod=5)
+        assert np.all(np.isnan(result[:4]))
+
+    def test_length(self):
+        assert len(SUM(_ARR, 5)) == N
+
+
+# ---------------------------------------------------------------------------
+# MAX
+# ---------------------------------------------------------------------------
+
+
+class TestMAX:
+    def test_known_values(self):
+        arr = np.array([1.0, 3.0, 2.0, 5.0, 4.0])
+        result = MAX(arr, timeperiod=3)
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        np.testing.assert_allclose(result[2], 3.0, rtol=1e-10)
+        np.testing.assert_allclose(result[3], 5.0, rtol=1e-10)
+        np.testing.assert_allclose(result[4], 5.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = MAX(_ARR, timeperiod=5)
+        assert np.all(np.isnan(result[:4]))
+
+    def test_length(self):
+        assert len(MAX(_ARR, 5)) == N
+
+
+# ---------------------------------------------------------------------------
+# MIN
+# ---------------------------------------------------------------------------
+
+
+class TestMIN:
+    def test_known_values(self):
+        arr = np.array([5.0, 3.0, 4.0, 1.0, 2.0])
+        result = MIN(arr, timeperiod=3)
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        np.testing.assert_allclose(result[2], 3.0, rtol=1e-10)
+        np.testing.assert_allclose(result[3], 1.0, rtol=1e-10)
+
+    def test_length(self):
+        assert len(MIN(_ARR, 5)) == N
+
+
+# ---------------------------------------------------------------------------
+# MAXINDEX
+# ---------------------------------------------------------------------------
+
+
+class TestMAXINDEX:
+    def test_known_values(self):
+        arr = np.array([1.0, 5.0, 3.0, 2.0, 4.0])
+        result = MAXINDEX(arr, timeperiod=3)
+        # warmup entries are -1 (sentinel for "no data")
+        assert result[0] < 0 and result[1] < 0
+        # window[0:3] = [1,5,3] → max at local index 1 → absolute index 1
+        np.testing.assert_allclose(result[2], 1.0, rtol=1e-10)
+        # window[2:5] = [3,2,4] → max at local index 2 → absolute index 4
+        np.testing.assert_allclose(result[4], 4.0, rtol=1e-10)
+
+    def test_length(self):
+        assert len(MAXINDEX(_ARR, 5)) == N
+
+
+# ---------------------------------------------------------------------------
+# MININDEX
+# ---------------------------------------------------------------------------
+
+
+class TestMININDEX:
+    def test_known_values(self):
+        arr = np.array([5.0, 1.0, 3.0, 2.0, 4.0])
+        result = MININDEX(arr, timeperiod=3)
+        # warmup entries are -1 (sentinel for "no data")
+        assert result[0] < 0 and result[1] < 0
+        # window[0:3] = [5,1,3] → min at local index 1 → absolute index 1
+        np.testing.assert_allclose(result[2], 1.0, rtol=1e-10)
+        # window[2:5] = [3,2,4] → min at local index 1 → absolute index 3
+        np.testing.assert_allclose(result[4], 3.0, rtol=1e-10)
+
+    def test_length(self):
+        assert len(MININDEX(_ARR, 5)) == N
+
+
+# ---------------------------------------------------------------------------
+# Trig functions
+# ---------------------------------------------------------------------------
+
+
+class TestSIN:
+    def test_known_values(self):
+        angles = np.array([0.0, np.pi / 2, np.pi])
+        result = SIN(angles)
+        np.testing.assert_allclose(result, np.sin(angles), atol=1e-10)
+
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(SIN(TRIG), np.sin(TRIG), rtol=1e-10)
+
+
+class TestCOS:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(COS(TRIG), np.cos(TRIG), rtol=1e-10)
+
+
+class TestTAN:
+    def test_matches_numpy(self):
+        safe = np.array([0.0, 0.5, 1.0])
+        np.testing.assert_allclose(TAN(safe), np.tan(safe), rtol=1e-10)
+
+
+class TestASIN:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(ASIN(UNIT), np.arcsin(UNIT), rtol=1e-10)
+
+
+class TestACOS:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(ACOS(UNIT), np.arccos(UNIT), rtol=1e-10)
+
+
+class TestATAN:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(ATAN(TRIG), np.arctan(TRIG), rtol=1e-10)
+
+
+class TestSINH:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(SINH(A3), np.sinh(A3), rtol=1e-10)
+
+
+class TestCOSH:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(COSH(A3), np.cosh(A3), rtol=1e-10)
+
+
+class TestTANH:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(TANH(UNIT), np.tanh(UNIT), rtol=1e-10)
+
+
+# ---------------------------------------------------------------------------
+# Rounding/exponential
+# ---------------------------------------------------------------------------
+
+
+class TestCEIL:
+    def test_known_values(self):
+        arr = np.array([1.1, 2.5, 3.9, -0.5])
+        np.testing.assert_allclose(CEIL(arr), np.ceil(arr), rtol=1e-10)
+
+
+class TestFLOOR:
+    def test_known_values(self):
+        arr = np.array([1.1, 2.5, 3.9, -0.5])
+        np.testing.assert_allclose(FLOOR(arr), np.floor(arr), rtol=1e-10)
+
+
+class TestEXP:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(EXP(A3), np.exp(A3), rtol=1e-10)
+
+    def test_exp_zero_is_one(self):
+        np.testing.assert_allclose(EXP(np.array([0.0])), [1.0], rtol=1e-10)
+
+
+class TestLN:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(LN(_ARR), np.log(_ARR), rtol=1e-10)
+
+    def test_ln_exp_inverse(self):
+        np.testing.assert_allclose(LN(EXP(A3)), A3, rtol=1e-10)
+
+
+class TestLOG10:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(LOG10(_ARR), np.log10(_ARR), rtol=1e-10)
+
+    def test_log10_of_100_is_2(self):
+        np.testing.assert_allclose(LOG10(np.array([100.0])), [2.0], rtol=1e-10)
+
+
+class TestSQRT:
+    def test_matches_numpy(self):
+        np.testing.assert_allclose(SQRT(_ARR), np.sqrt(_ARR), rtol=1e-10)
+
+    def test_sqrt_of_4_is_2(self):
+        np.testing.assert_allclose(SQRT(np.array([4.0])), [2.0], rtol=1e-10)

ferro-ta-main/tests/unit/indicators/test_momentum.py

@@ -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))

ferro-ta-main/tests/unit/indicators/test_overlap.py

@@ -0,0 +1,484 @@
+"""Unit tests for ferro_ta.indicators.overlap"""
+
+import numpy as np
+
+from ferro_ta.indicators.overlap import (
+    BBANDS,
+    DEMA,
+    EMA,
+    KAMA,
+    MA,
+    MACD,
+    MACDEXT,
+    MACDFIX,
+    MAMA,
+    MAVP,
+    MIDPOINT,
+    MIDPRICE,
+    SAR,
+    SAREXT,
+    SMA,
+    T3,
+    TEMA,
+    TRIMA,
+    WMA,
+)
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(42)
+N = 200
+_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))
+
+SMALL5 = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+SMALL5_HIGH = np.array([11.0, 12.0, 13.0, 14.0, 15.0])
+SMALL5_LOW = np.array([9.0, 10.0, 11.0, 12.0, 13.0])
+
+
+# ---------------------------------------------------------------------------
+# SMA
+# ---------------------------------------------------------------------------
+
+
+class TestSMA:
+    def test_known_values(self):
+        result = SMA(SMALL5, timeperiod=3)
+        expected = np.array([np.nan, np.nan, 11.0, 12.0, 13.0])
+        np.testing.assert_allclose(result[2:], expected[2:], rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = SMA(SMALL5, timeperiod=3)
+        assert np.all(np.isnan(result[:2]))
+
+    def test_length(self):
+        result = SMA(_CLOSE, timeperiod=20)
+        assert len(result) == N
+
+    def test_nan_warmup_long(self):
+        result = SMA(_CLOSE, timeperiod=20)
+        assert np.all(np.isnan(result[:19]))
+        assert np.all(np.isfinite(result[19:]))
+
+
+# ---------------------------------------------------------------------------
+# EMA
+# ---------------------------------------------------------------------------
+
+
+class TestEMA:
+    def test_known_values(self):
+        # k = 2/(3+1) = 0.5; seed = SMA(3) = 11.0
+        # EMA[2] = SMA([10,11,12]) = 11.0
+        # EMA[3] = close[3]*k + EMA[2]*(1-k) = 13*0.5 + 11.0*0.5 = 12.0
+        # EMA[4] = close[4]*k + EMA[3]*(1-k) = 14*0.5 + 12.0*0.5 = 13.0
+        result = EMA(SMALL5, timeperiod=3)
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        np.testing.assert_allclose(result[2], 11.0, rtol=1e-10)
+        np.testing.assert_allclose(result[3], 12.0, rtol=1e-10)
+        np.testing.assert_allclose(result[4], 13.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = EMA(SMALL5, timeperiod=3)
+        assert np.all(np.isnan(result[:2]))
+
+    def test_length(self):
+        assert len(EMA(_CLOSE, 20)) == N
+
+    def test_monotone_on_rising(self):
+        rising = np.arange(1.0, 51.0)
+        result = EMA(rising, 5)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.diff(valid) > 0)
+
+
+# ---------------------------------------------------------------------------
+# WMA
+# ---------------------------------------------------------------------------
+
+
+class TestWMA:
+    def test_known_values(self):
+        arr = np.arange(1.0, 6.0)
+        result = WMA(arr, timeperiod=3)
+        # weights 1,2,3 / 6
+        expected_2 = (1 * 1 + 2 * 2 + 3 * 3) / 6.0  # 14/6
+        expected_3 = (1 * 2 + 2 * 3 + 3 * 4) / 6.0  # 20/6
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        np.testing.assert_allclose(result[2], expected_2, rtol=1e-10)
+        np.testing.assert_allclose(result[3], expected_3, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = WMA(_CLOSE, timeperiod=10)
+        assert np.all(np.isnan(result[:9]))
+
+    def test_length(self):
+        assert len(WMA(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# DEMA
+# ---------------------------------------------------------------------------
+
+
+class TestDEMA:
+    def test_nan_warmup(self):
+        result = DEMA(_CLOSE, timeperiod=5)
+        assert np.all(np.isnan(result[:8]))  # DEMA needs 2*(tp-1) bars
+
+    def test_length(self):
+        assert len(DEMA(_CLOSE, 5)) == N
+
+    def test_values_finite_after_warmup(self):
+        result = DEMA(_CLOSE, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        assert len(valid) > 0
+        assert np.all(np.isfinite(valid))
+
+    def test_tracks_close(self):
+        # DEMA is more responsive than EMA; on trending data it should lead EMA
+        rising = np.linspace(10.0, 100.0, 100)
+        dema = DEMA(rising, 5)
+        ema = EMA(rising, 5)
+        valid = ~np.isnan(dema) & ~np.isnan(ema)
+        # DEMA > EMA on a rising series (lower lag)
+        assert np.all(dema[valid] >= ema[valid] - 1e-9)
+
+
+# ---------------------------------------------------------------------------
+# TEMA
+# ---------------------------------------------------------------------------
+
+
+class TestTEMA:
+    def test_nan_warmup(self):
+        result = TEMA(_CLOSE, timeperiod=5)
+        assert np.all(np.isnan(result[:12]))
+
+    def test_length(self):
+        assert len(TEMA(_CLOSE, 5)) == N
+
+    def test_values_finite_after_warmup(self):
+        result = TEMA(_CLOSE, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        assert len(valid) > 0
+        assert np.all(np.isfinite(valid))
+
+
+# ---------------------------------------------------------------------------
+# TRIMA
+# ---------------------------------------------------------------------------
+
+
+class TestTRIMA:
+    def test_known_values(self):
+        arr = np.arange(1.0, 11.0)
+        result = TRIMA(arr, timeperiod=5)
+        # TRIMA(5) is SMA of SMA(3) on a 5-window
+        assert np.all(np.isnan(result[:4]))
+        np.testing.assert_allclose(result[4], 3.0, rtol=1e-10)
+        np.testing.assert_allclose(result[5], 4.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = TRIMA(_CLOSE, timeperiod=10)
+        assert np.all(np.isnan(result[:9]))
+
+    def test_length(self):
+        assert len(TRIMA(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# KAMA
+# ---------------------------------------------------------------------------
+
+
+class TestKAMA:
+    def test_nan_warmup(self):
+        result = KAMA(_CLOSE, timeperiod=10)
+        assert np.all(np.isnan(result[:9]))
+
+    def test_length(self):
+        assert len(KAMA(_CLOSE, 10)) == N
+
+    def test_seed_equals_close(self):
+        arr = np.arange(1.0, 21.0)
+        result = KAMA(arr, timeperiod=10)
+        # First valid KAMA value equals close at warmup index
+        np.testing.assert_allclose(result[9], arr[9], rtol=1e-10)
+
+    def test_finite_after_warmup(self):
+        result = KAMA(_CLOSE, timeperiod=10)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+
+# ---------------------------------------------------------------------------
+# T3
+# ---------------------------------------------------------------------------
+
+
+class TestT3:
+    def test_nan_warmup(self):
+        arr = np.linspace(10.0, 30.0, 100)
+        result = T3(arr, timeperiod=5)
+        # warmup for T3(tp) = 6*(tp-1)
+        assert np.all(np.isnan(result[:24]))
+
+    def test_length(self):
+        assert len(T3(_CLOSE, timeperiod=5)) == N
+
+    def test_finite_after_warmup(self):
+        arr = np.linspace(10.0, 30.0, 100)
+        result = T3(arr, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        assert len(valid) > 0
+        assert np.all(np.isfinite(valid))
+
+    def test_trending(self):
+        rising = np.linspace(10.0, 200.0, 150)
+        result = T3(rising, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.diff(valid) > 0)
+
+
+# ---------------------------------------------------------------------------
+# MA
+# ---------------------------------------------------------------------------
+
+
+class TestMA:
+    def test_default_is_sma(self):
+        result_ma = MA(_CLOSE, timeperiod=10, matype=0)
+        result_sma = SMA(_CLOSE, timeperiod=10)
+        np.testing.assert_allclose(result_ma, result_sma, rtol=1e-10, equal_nan=True)
+
+    def test_ema_matype(self):
+        result_ma = MA(_CLOSE, timeperiod=10, matype=1)
+        result_ema = EMA(_CLOSE, timeperiod=10)
+        np.testing.assert_allclose(result_ma, result_ema, rtol=1e-10, equal_nan=True)
+
+    def test_length(self):
+        assert len(MA(_CLOSE, 10)) == N
+
+
+# ---------------------------------------------------------------------------
+# MACD
+# ---------------------------------------------------------------------------
+
+
+class TestMACD:
+    def test_returns_three_arrays(self):
+        result = MACD(_CLOSE, 12, 26, 9)
+        assert isinstance(result, tuple) and len(result) == 3
+
+    def test_length(self):
+        macd, signal, hist = MACD(_CLOSE, 12, 26, 9)
+        assert len(macd) == len(signal) == len(hist) == N
+
+    def test_histogram_is_diff(self):
+        macd, signal, hist = MACD(_CLOSE)
+        valid = ~np.isnan(macd) & ~np.isnan(signal)
+        np.testing.assert_allclose(hist[valid], macd[valid] - signal[valid], atol=1e-10)
+
+    def test_nan_warmup(self):
+        macd, signal, hist = MACD(_CLOSE, 12, 26, 9)
+        # MACD line: warmup = slowperiod - 1 = 25
+        assert np.all(np.isnan(macd[:25]))
+
+
+# ---------------------------------------------------------------------------
+# MACDFIX
+# ---------------------------------------------------------------------------
+
+
+class TestMACDFIX:
+    def test_returns_three_arrays(self):
+        result = MACDFIX(_CLOSE)
+        assert isinstance(result, tuple) and len(result) == 3
+
+    def test_histogram_is_diff(self):
+        macd, signal, hist = MACDFIX(_CLOSE)
+        valid = ~np.isnan(macd) & ~np.isnan(signal)
+        np.testing.assert_allclose(hist[valid], macd[valid] - signal[valid], atol=1e-10)
+
+    def test_length(self):
+        macd, signal, hist = MACDFIX(_CLOSE)
+        assert len(macd) == N
+
+
+# ---------------------------------------------------------------------------
+# MACDEXT
+# ---------------------------------------------------------------------------
+
+
+class TestMACDEXT:
+    def test_returns_three_arrays(self):
+        result = MACDEXT(_CLOSE)
+        assert isinstance(result, tuple) and len(result) == 3
+
+    def test_histogram_is_diff(self):
+        macd, signal, hist = MACDEXT(_CLOSE)
+        valid = ~np.isnan(macd) & ~np.isnan(signal)
+        np.testing.assert_allclose(hist[valid], macd[valid] - signal[valid], atol=1e-10)
+
+    def test_length(self):
+        assert len(MACDEXT(_CLOSE)[0]) == N
+
+
+# ---------------------------------------------------------------------------
+# BBANDS
+# ---------------------------------------------------------------------------
+
+
+class TestBBANDS:
+    def test_returns_three_arrays(self):
+        result = BBANDS(_CLOSE, 20)
+        assert isinstance(result, tuple) and len(result) == 3
+
+    def test_middle_is_sma(self):
+        upper, middle, lower = BBANDS(_CLOSE, timeperiod=20)
+        sma = SMA(_CLOSE, timeperiod=20)
+        np.testing.assert_allclose(middle, sma, rtol=1e-10, equal_nan=True)
+
+    def test_bands_symmetric(self):
+        upper, middle, lower = BBANDS(_CLOSE, 20, nbdevup=2.0, nbdevdn=2.0)
+        valid = ~np.isnan(upper)
+        np.testing.assert_allclose(
+            upper[valid] - middle[valid],
+            middle[valid] - lower[valid],
+            rtol=1e-10,
+        )
+
+    def test_nan_warmup(self):
+        upper, middle, lower = BBANDS(_CLOSE, 20)
+        assert np.all(np.isnan(middle[:19]))
+
+
+# ---------------------------------------------------------------------------
+# SAR
+# ---------------------------------------------------------------------------
+
+
+class TestSAR:
+    def test_length(self):
+        result = SAR(_HIGH, _LOW)
+        assert len(result) == N
+
+    def test_first_is_nan(self):
+        result = SAR(_HIGH, _LOW)
+        assert np.isnan(result[0])
+
+    def test_finite_after_warmup(self):
+        result = SAR(_HIGH, _LOW)
+        assert np.all(np.isfinite(result[1:]))
+
+
+# ---------------------------------------------------------------------------
+# SAREXT
+# ---------------------------------------------------------------------------
+
+
+class TestSAREXT:
+    def test_length(self):
+        result = SAREXT(_HIGH, _LOW)
+        assert len(result) == N
+
+    def test_first_is_nan(self):
+        result = SAREXT(_HIGH, _LOW)
+        assert np.isnan(result[0])
+
+    def test_finite_after_warmup(self):
+        result = SAREXT(_HIGH, _LOW)
+        assert np.all(np.isfinite(result[1:]))
+
+
+# ---------------------------------------------------------------------------
+# MAMA
+# ---------------------------------------------------------------------------
+
+
+class TestMAMA:
+    def test_returns_two_arrays(self):
+        result = MAMA(_CLOSE)
+        assert isinstance(result, tuple) and len(result) == 2
+
+    def test_length(self):
+        mama, fama = MAMA(_CLOSE)
+        assert len(mama) == len(fama) == N
+
+    def test_nan_warmup(self):
+        mama, fama = MAMA(_CLOSE)
+        assert np.all(np.isnan(mama[:32]))
+
+    def test_mama_ge_fama(self):
+        # MAMA is adaptive; on average MAMA >= FAMA on a trending up series
+        rising = np.linspace(10.0, 200.0, 200)
+        mama, fama = MAMA(rising)
+        valid = ~np.isnan(mama) & ~np.isnan(fama)
+        # not strictly guaranteed, just check output is finite
+        assert np.all(np.isfinite(mama[valid]))
+
+
+# ---------------------------------------------------------------------------
+# MAVP
+# ---------------------------------------------------------------------------
+
+
+class TestMAVP:
+    def test_length(self):
+        arr = np.linspace(10.0, 30.0, 50)
+        periods = np.full(50, 5.0)
+        result = MAVP(arr, periods, minperiod=2, maxperiod=10)
+        assert len(result) == 50
+
+    def test_finite_for_large_enough_data(self):
+        arr = np.linspace(10.0, 30.0, 50)
+        periods = np.full(50, 3.0)
+        result = MAVP(arr, periods, minperiod=2, maxperiod=10)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+
+# ---------------------------------------------------------------------------
+# MIDPOINT
+# ---------------------------------------------------------------------------
+
+
+class TestMIDPOINT:
+    def test_known_values(self):
+        arr = np.array([10.0, 12.0, 14.0, 16.0, 18.0])
+        result = MIDPOINT(arr, timeperiod=3)
+        # MIDPOINT(n) = (max + min) / 2 over window
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        np.testing.assert_allclose(result[2], (10.0 + 14.0) / 2.0, rtol=1e-10)
+        np.testing.assert_allclose(result[4], (14.0 + 18.0) / 2.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = MIDPOINT(_CLOSE, timeperiod=14)
+        assert np.all(np.isnan(result[:13]))
+
+    def test_length(self):
+        assert len(MIDPOINT(_CLOSE, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# MIDPRICE
+# ---------------------------------------------------------------------------
+
+
+class TestMIDPRICE:
+    def test_known_values(self):
+        result = MIDPRICE(SMALL5_HIGH, SMALL5_LOW, timeperiod=3)
+        assert np.isnan(result[0]) and np.isnan(result[1])
+        # window [0..2]: max_high=13, min_low=9  → (13+9)/2 = 11
+        np.testing.assert_allclose(result[2], 11.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = MIDPRICE(_HIGH, _LOW, timeperiod=14)
+        assert np.all(np.isnan(result[:13]))
+
+    def test_length(self):
+        assert len(MIDPRICE(_HIGH, _LOW, 14)) == N

ferro-ta-main/tests/unit/indicators/test_pattern.py

@@ -0,0 +1,260 @@
+"""Unit tests for ferro_ta.indicators.pattern (CDL* functions)"""
+
+import numpy as np
+import pytest
+
+from ferro_ta.indicators.pattern import (
+    CDL2CROWS,
+    CDL3BLACKCROWS,
+    CDL3INSIDE,
+    CDL3LINESTRIKE,
+    CDL3OUTSIDE,
+    CDL3STARSINSOUTH,
+    CDL3WHITESOLDIERS,
+    CDLABANDONEDBABY,
+    CDLADVANCEBLOCK,
+    CDLBELTHOLD,
+    CDLBREAKAWAY,
+    CDLCLOSINGMARUBOZU,
+    CDLCONCEALBABYSWALL,
+    CDLCOUNTERATTACK,
+    CDLDARKCLOUDCOVER,
+    CDLDOJI,
+    CDLDOJISTAR,
+    CDLDRAGONFLYDOJI,
+    CDLENGULFING,
+    CDLEVENINGDOJISTAR,
+    CDLEVENINGSTAR,
+    CDLGAPSIDESIDEWHITE,
+    CDLGRAVESTONEDOJI,
+    CDLHAMMER,
+    CDLHANGINGMAN,
+    CDLHARAMI,
+    CDLHARAMICROSS,
+    CDLHIGHWAVE,
+    CDLHIKKAKE,
+    CDLHIKKAKEMOD,
+    CDLHOMINGPIGEON,
+    CDLIDENTICAL3CROWS,
+    CDLINNECK,
+    CDLINVERTEDHAMMER,
+    CDLKICKING,
+    CDLKICKINGBYLENGTH,
+    CDLLADDERBOTTOM,
+    CDLLONGLEGGEDDOJI,
+    CDLLONGLINE,
+    CDLMARUBOZU,
+    CDLMATCHINGLOW,
+    CDLMATHOLD,
+    CDLMORNINGDOJISTAR,
+    CDLMORNINGSTAR,
+    CDLONNECK,
+    CDLPIERCING,
+    CDLRICKSHAWMAN,
+    CDLRISEFALL3METHODS,
+    CDLSEPARATINGLINES,
+    CDLSHOOTINGSTAR,
+    CDLSHORTLINE,
+    CDLSPINNINGTOP,
+    CDLSTALLEDPATTERN,
+    CDLSTICKSANDWICH,
+    CDLTAKURI,
+    CDLTASUKIGAP,
+    CDLTHRUSTING,
+    CDLTRISTAR,
+    CDLUNIQUE3RIVER,
+    CDLUPSIDEGAP2CROWS,
+    CDLXSIDEGAP3METHODS,
+)
+
+# ---------------------------------------------------------------------------
+# Shared random OHLCV data (realistic OHLCV, proper H >= O,C >= L)
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(42)
+N = 200
+_C = 100 + np.cumsum(RNG.normal(0, 0.5, N))
+_O = _C + RNG.normal(0, 0.2, N)
+_H = np.maximum(np.maximum(_O, _C) + np.abs(RNG.normal(0, 0.3, N)), np.maximum(_O, _C))
+_L = np.minimum(np.minimum(_O, _C) - np.abs(RNG.normal(0, 0.3, N)), np.minimum(_O, _C))
+
+# All CDL* functions to test systematically
+ALL_CDL = [
+    ("CDL2CROWS", CDL2CROWS),
+    ("CDL3BLACKCROWS", CDL3BLACKCROWS),
+    ("CDL3INSIDE", CDL3INSIDE),
+    ("CDL3LINESTRIKE", CDL3LINESTRIKE),
+    ("CDL3OUTSIDE", CDL3OUTSIDE),
+    ("CDL3STARSINSOUTH", CDL3STARSINSOUTH),
+    ("CDL3WHITESOLDIERS", CDL3WHITESOLDIERS),
+    ("CDLABANDONEDBABY", CDLABANDONEDBABY),
+    ("CDLADVANCEBLOCK", CDLADVANCEBLOCK),
+    ("CDLBELTHOLD", CDLBELTHOLD),
+    ("CDLBREAKAWAY", CDLBREAKAWAY),
+    ("CDLCLOSINGMARUBOZU", CDLCLOSINGMARUBOZU),
+    ("CDLCONCEALBABYSWALL", CDLCONCEALBABYSWALL),
+    ("CDLCOUNTERATTACK", CDLCOUNTERATTACK),
+    ("CDLDARKCLOUDCOVER", CDLDARKCLOUDCOVER),
+    ("CDLDOJI", CDLDOJI),
+    ("CDLDOJISTAR", CDLDOJISTAR),
+    ("CDLDRAGONFLYDOJI", CDLDRAGONFLYDOJI),
+    ("CDLENGULFING", CDLENGULFING),
+    ("CDLEVENINGDOJISTAR", CDLEVENINGDOJISTAR),
+    ("CDLEVENINGSTAR", CDLEVENINGSTAR),
+    ("CDLGAPSIDESIDEWHITE", CDLGAPSIDESIDEWHITE),
+    ("CDLGRAVESTONEDOJI", CDLGRAVESTONEDOJI),
+    ("CDLHAMMER", CDLHAMMER),
+    ("CDLHANGINGMAN", CDLHANGINGMAN),
+    ("CDLHARAMI", CDLHARAMI),
+    ("CDLHARAMICROSS", CDLHARAMICROSS),
+    ("CDLHIGHWAVE", CDLHIGHWAVE),
+    ("CDLHIKKAKE", CDLHIKKAKE),
+    ("CDLHIKKAKEMOD", CDLHIKKAKEMOD),
+    ("CDLHOMINGPIGEON", CDLHOMINGPIGEON),
+    ("CDLIDENTICAL3CROWS", CDLIDENTICAL3CROWS),
+    ("CDLINNECK", CDLINNECK),
+    ("CDLINVERTEDHAMMER", CDLINVERTEDHAMMER),
+    ("CDLKICKING", CDLKICKING),
+    ("CDLKICKINGBYLENGTH", CDLKICKINGBYLENGTH),
+    ("CDLLADDERBOTTOM", CDLLADDERBOTTOM),
+    ("CDLLONGLEGGEDDOJI", CDLLONGLEGGEDDOJI),
+    ("CDLLONGLINE", CDLLONGLINE),
+    ("CDLMARUBOZU", CDLMARUBOZU),
+    ("CDLMATCHINGLOW", CDLMATCHINGLOW),
+    ("CDLMATHOLD", CDLMATHOLD),
+    ("CDLMORNINGDOJISTAR", CDLMORNINGDOJISTAR),
+    ("CDLMORNINGSTAR", CDLMORNINGSTAR),
+    ("CDLONNECK", CDLONNECK),
+    ("CDLPIERCING", CDLPIERCING),
+    ("CDLRICKSHAWMAN", CDLRICKSHAWMAN),
+    ("CDLRISEFALL3METHODS", CDLRISEFALL3METHODS),
+    ("CDLSEPARATINGLINES", CDLSEPARATINGLINES),
+    ("CDLSHOOTINGSTAR", CDLSHOOTINGSTAR),
+    ("CDLSHORTLINE", CDLSHORTLINE),
+    ("CDLSPINNINGTOP", CDLSPINNINGTOP),
+    ("CDLSTALLEDPATTERN", CDLSTALLEDPATTERN),
+    ("CDLSTICKSANDWICH", CDLSTICKSANDWICH),
+    ("CDLTAKURI", CDLTAKURI),
+    ("CDLTASUKIGAP", CDLTASUKIGAP),
+    ("CDLTHRUSTING", CDLTHRUSTING),
+    ("CDLTRISTAR", CDLTRISTAR),
+    ("CDLUNIQUE3RIVER", CDLUNIQUE3RIVER),
+    ("CDLUPSIDEGAP2CROWS", CDLUPSIDEGAP2CROWS),
+    ("CDLXSIDEGAP3METHODS", CDLXSIDEGAP3METHODS),
+]
+
+
+# ---------------------------------------------------------------------------
+# Parametrised tests: all CDL patterns
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("name,fn", ALL_CDL)
+def test_cdl_output_length(name, fn):
+    result = fn(_O, _H, _L, _C)
+    assert len(result) == N, f"{name}: expected length {N}, got {len(result)}"
+
+
+@pytest.mark.parametrize("name,fn", ALL_CDL)
+def test_cdl_values_in_valid_set(name, fn):
+    result = fn(_O, _H, _L, _C)
+    assert np.all(np.isin(result, [-100, 0, 100])), (
+        f"{name}: unexpected values {np.unique(result)}"
+    )
+
+
+@pytest.mark.parametrize("name,fn", ALL_CDL)
+def test_cdl_no_nan(name, fn):
+    result = fn(_O, _H, _L, _C)
+    assert np.all(np.isfinite(result.astype(float))), f"{name}: contains NaN/Inf"
+
+
+# ---------------------------------------------------------------------------
+# Specific tests for previously untested patterns
+# ---------------------------------------------------------------------------
+
+
+class TestCDLSPINNINGTOP:
+    def test_detects_pattern(self):
+        # Spinning top: small body, long upper and lower shadows
+        # open ≈ close (small body), high much higher, low much lower
+        o = np.array([10.0, 10.1, 10.0])
+        h = np.array([15.0, 15.1, 15.0])
+        l = np.array([5.0, 5.1, 5.0])
+        c = np.array([10.0, 10.0, 10.05])
+        result = CDLSPINNINGTOP(o, h, l, c)
+        assert np.all(np.isin(result, [-100, 0, 100]))
+
+    def test_output_values_random(self):
+        result = CDLSPINNINGTOP(_O, _H, _L, _C)
+        assert np.all(np.isin(result, [-100, 0, 100]))
+
+
+class TestCDLEVENINGSTAR:
+    def test_basic_run(self):
+        result = CDLEVENINGSTAR(_O, _H, _L, _C)
+        assert len(result) == N
+        assert np.all(np.isin(result, [-100, 0, 100]))
+
+    def test_large_dataset_has_valid_output(self):
+        # On 200 bars of random data, result should be all in {-100,0,100}
+        result = CDLEVENINGSTAR(_O, _H, _L, _C)
+        assert np.all(np.isin(result, [-100, 0, 100]))
+
+
+class TestCDLMORNINGSTAR:
+    def test_basic_run(self):
+        result = CDLMORNINGSTAR(_O, _H, _L, _C)
+        assert len(result) == N
+        assert np.all(np.isin(result, [-100, 0, 100]))
+
+    def test_bullish_signal_is_100(self):
+        # Any detected signal must be 100 (bullish)
+        result = CDLMORNINGSTAR(_O, _H, _L, _C)
+        assert np.all(result[result != 0] == 100)
+
+
+class TestCDL2CROWS:
+    def test_basic_run(self):
+        result = CDL2CROWS(_O, _H, _L, _C)
+        assert len(result) == N
+        assert np.all(np.isin(result, [-100, 0, 100]))
+
+    def test_bearish_signal_is_minus_100(self):
+        # Any detected signal must be -100 (bearish)
+        result = CDL2CROWS(_O, _H, _L, _C)
+        assert np.all(result[result != 0] == -100)
+
+
+class TestCDLDOJI:
+    def test_detects_doji(self):
+        # Exact doji: open == close
+        o = np.array([10.0, 10.0, 10.0])
+        h = np.array([12.0, 12.0, 12.0])
+        l = np.array([8.0, 8.0, 8.0])
+        c = np.array([10.0, 10.0, 10.0])
+        result = CDLDOJI(o, h, l, c)
+        assert np.all(result == 100)
+
+    def test_non_doji_returns_zero(self):
+        o = np.array([10.0, 11.0, 12.0])
+        h = np.array([15.0, 16.0, 17.0])
+        l = np.array([9.0, 10.0, 11.0])
+        c = np.array([14.0, 15.0, 16.0])  # large body, not doji
+        result = CDLDOJI(o, h, l, c)
+        assert np.all(result == 0)
+
+
+class TestCDLMARUBOZU:
+    def test_detects_bullish_marubozu(self):
+        # Bullish marubozu: open == low, close == high, close > open
+        o = np.array([10.0, 10.0])
+        h = np.array([15.0, 15.0])
+        l = np.array([10.0, 10.0])
+        c = np.array([15.0, 15.0])
+        result = CDLMARUBOZU(o, h, l, c)
+        assert np.all(np.isin(result, [-100, 0, 100]))
+
+    def test_length(self):
+        result = CDLMARUBOZU(_O, _H, _L, _C)
+        assert len(result) == N

ferro-ta-main/tests/unit/indicators/test_price_transform.py

@@ -0,0 +1,113 @@
+"""Unit tests for ferro_ta.indicators.price_transform"""
+
+import numpy as np
+
+from ferro_ta.indicators.price_transform import AVGPRICE, MEDPRICE, TYPPRICE, WCLPRICE
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+O = np.array([10.0, 11.0, 12.0, 13.0])
+H = np.array([12.0, 13.0, 14.0, 15.0])
+L = np.array([9.0, 10.0, 11.0, 12.0])
+C = np.array([11.0, 12.0, 13.0, 14.0])
+
+
+# ---------------------------------------------------------------------------
+# AVGPRICE
+# ---------------------------------------------------------------------------
+
+
+class TestAVGPRICE:
+    def test_known_formula(self):
+        result = AVGPRICE(O, H, L, C)
+        expected = (O + H + L + C) / 4.0
+        np.testing.assert_allclose(result, expected, rtol=1e-10)
+
+    def test_first_bar(self):
+        result = AVGPRICE(O, H, L, C)
+        np.testing.assert_allclose(result[0], (10 + 12 + 9 + 11) / 4.0, rtol=1e-10)
+
+    def test_no_nan(self):
+        result = AVGPRICE(O, H, L, C)
+        assert np.all(np.isfinite(result))
+
+    def test_length(self):
+        assert len(AVGPRICE(O, H, L, C)) == len(O)
+
+
+# ---------------------------------------------------------------------------
+# MEDPRICE
+# ---------------------------------------------------------------------------
+
+
+class TestMEDPRICE:
+    def test_known_formula(self):
+        result = MEDPRICE(H, L)
+        expected = (H + L) / 2.0
+        np.testing.assert_allclose(result, expected, rtol=1e-10)
+
+    def test_first_bar(self):
+        result = MEDPRICE(H, L)
+        np.testing.assert_allclose(result[0], (12 + 9) / 2.0, rtol=1e-10)
+
+    def test_no_nan(self):
+        result = MEDPRICE(H, L)
+        assert np.all(np.isfinite(result))
+
+    def test_length(self):
+        assert len(MEDPRICE(H, L)) == len(H)
+
+
+# ---------------------------------------------------------------------------
+# TYPPRICE
+# ---------------------------------------------------------------------------
+
+
+class TestTYPPRICE:
+    def test_known_formula(self):
+        result = TYPPRICE(H, L, C)
+        expected = (H + L + C) / 3.0
+        np.testing.assert_allclose(result, expected, rtol=1e-10)
+
+    def test_first_bar(self):
+        result = TYPPRICE(H, L, C)
+        np.testing.assert_allclose(result[0], (12 + 9 + 11) / 3.0, rtol=1e-10)
+
+    def test_no_nan(self):
+        result = TYPPRICE(H, L, C)
+        assert np.all(np.isfinite(result))
+
+    def test_length(self):
+        assert len(TYPPRICE(H, L, C)) == len(H)
+
+
+# ---------------------------------------------------------------------------
+# WCLPRICE
+# ---------------------------------------------------------------------------
+
+
+class TestWCLPRICE:
+    def test_known_formula(self):
+        result = WCLPRICE(H, L, C)
+        expected = (H + L + 2.0 * C) / 4.0
+        np.testing.assert_allclose(result, expected, rtol=1e-10)
+
+    def test_first_bar(self):
+        result = WCLPRICE(H, L, C)
+        np.testing.assert_allclose(result[0], (12 + 9 + 2 * 11) / 4.0, rtol=1e-10)
+
+    def test_no_nan(self):
+        result = WCLPRICE(H, L, C)
+        assert np.all(np.isfinite(result))
+
+    def test_close_weight_double(self):
+        # WCLPRICE weights close twice vs TYPPRICE
+        wcl = WCLPRICE(H, L, C)
+        # On a rising series (H > L > 0), WCLPRICE > TYPPRICE when C > (H+L)/2
+        # Just verify formula correctness already done above
+        assert np.all(np.isfinite(wcl))
+
+    def test_length(self):
+        assert len(WCLPRICE(H, L, C)) == len(H)

ferro-ta-main/tests/unit/indicators/test_statistic.py

@@ -0,0 +1,488 @@
+"""Unit tests for ferro_ta.indicators.statistic"""
+
+import numpy as np
+import pytest
+
+from ferro_ta.indicators.statistic import (
+    BATCH_DTW,
+    BETA,
+    CORREL,
+    DTW,
+    DTW_DISTANCE,
+    LINEARREG,
+    LINEARREG_ANGLE,
+    LINEARREG_INTERCEPT,
+    LINEARREG_SLOPE,
+    STDDEV,
+    TSF,
+    VAR,
+)
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(11)
+N = 100
+_A = 100 + np.cumsum(RNG.normal(0, 0.5, N))
+_B = 100 + np.cumsum(RNG.normal(0, 0.5, N))
+
+LINDATA = np.arange(1.0, 6.0)  # [1,2,3,4,5]
+CONSTDATA = np.ones(10)  # all 1.0
+
+
+def _naive_linreg_window(window: np.ndarray) -> tuple[float, float]:
+    x = np.arange(len(window), dtype=np.float64)
+    sum_x = float(np.sum(x))
+    sum_y = float(np.sum(window))
+    sum_xy = float(np.sum(x * window))
+    sum_x2 = float(np.sum(x * x))
+    n = float(len(window))
+    denom = n * sum_x2 - sum_x * sum_x
+    slope = (n * sum_xy - sum_x * sum_y) / denom if denom != 0.0 else 0.0
+    intercept = (sum_y - slope * sum_x) / n
+    return slope, intercept
+
+
+def _naive_linearreg(series: np.ndarray, timeperiod: int, x_value: float) -> np.ndarray:
+    out = np.full(len(series), np.nan, dtype=np.float64)
+    for end in range(timeperiod - 1, len(series)):
+        slope, intercept = _naive_linreg_window(series[end + 1 - timeperiod : end + 1])
+        out[end] = intercept + slope * x_value
+    return out
+
+
+def _naive_correl(x: np.ndarray, y: np.ndarray, timeperiod: int) -> np.ndarray:
+    out = np.full(len(x), np.nan, dtype=np.float64)
+    for end in range(timeperiod - 1, len(x)):
+        x_window = x[end + 1 - timeperiod : end + 1]
+        y_window = y[end + 1 - timeperiod : end + 1]
+        mean_x = float(np.sum(x_window)) / timeperiod
+        mean_y = float(np.sum(y_window)) / timeperiod
+        cov = float(np.sum((x_window - mean_x) * (y_window - mean_y)))
+        std_x = float(np.sqrt(np.sum((x_window - mean_x) ** 2)))
+        std_y = float(np.sqrt(np.sum((y_window - mean_y) ** 2)))
+        denom = std_x * std_y
+        out[end] = cov / denom if denom != 0.0 else np.nan
+    return out
+
+
+def _naive_beta(x: np.ndarray, y: np.ndarray, timeperiod: int) -> np.ndarray:
+    out = np.full(len(x), np.nan, dtype=np.float64)
+    for end in range(timeperiod, len(x)):
+        start = end - timeperiod
+        rx = np.array(
+            [
+                x[idx + 1] / x[idx] - 1.0 if x[idx] != 0.0 else np.nan
+                for idx in range(start, end)
+            ],
+            dtype=np.float64,
+        )
+        ry = np.array(
+            [
+                y[idx + 1] / y[idx] - 1.0 if y[idx] != 0.0 else np.nan
+                for idx in range(start, end)
+            ],
+            dtype=np.float64,
+        )
+        mean_x = float(np.sum(rx)) / timeperiod
+        mean_y = float(np.sum(ry)) / timeperiod
+        cov = float(np.sum((rx - mean_x) * (ry - mean_y))) / timeperiod
+        var_x = float(np.sum((rx - mean_x) ** 2)) / timeperiod
+        out[end] = cov / var_x if var_x != 0.0 else np.nan
+    return out
+
+
+# ---------------------------------------------------------------------------
+# STDDEV
+# ---------------------------------------------------------------------------
+
+
+class TestSTDDEV:
+    def test_constant_is_zero(self):
+        result = STDDEV(CONSTDATA, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, 0.0, atol=1e-10)
+
+    def test_known_values(self):
+        # std([1,2,3,4,5], ddof=0) = sqrt(2)
+        result = STDDEV(LINDATA, timeperiod=5)
+        np.testing.assert_allclose(result[4], np.sqrt(2.0), rtol=1e-6)
+
+    def test_nan_warmup(self):
+        result = STDDEV(_A, timeperiod=5)
+        assert np.all(np.isnan(result[:4]))
+
+    def test_length(self):
+        assert len(STDDEV(_A, 5)) == N
+
+    def test_positive(self):
+        result = STDDEV(_A, 5)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0)
+
+
+# ---------------------------------------------------------------------------
+# VAR
+# ---------------------------------------------------------------------------
+
+
+class TestVAR:
+    def test_constant_is_zero(self):
+        result = VAR(CONSTDATA, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, 0.0, atol=1e-10)
+
+    def test_known_values(self):
+        # var([1,2,3,4,5], ddof=0) = 2.0
+        result = VAR(LINDATA, timeperiod=5)
+        np.testing.assert_allclose(result[4], 2.0, rtol=1e-6)
+
+    def test_equals_stddev_squared(self):
+        std = STDDEV(_A, timeperiod=10)
+        var = VAR(_A, timeperiod=10)
+        valid = ~np.isnan(std) & ~np.isnan(var)
+        np.testing.assert_allclose(var[valid], std[valid] ** 2, rtol=1e-6)
+
+    def test_length(self):
+        assert len(VAR(_A, 5)) == N
+
+
+# ---------------------------------------------------------------------------
+# LINEARREG
+# ---------------------------------------------------------------------------
+
+
+class TestLINEARREG:
+    def test_perfect_line(self):
+        # For [1,2,3,4,5] over window 5, forecast = 5.0
+        result = LINEARREG(LINDATA, timeperiod=5)
+        np.testing.assert_allclose(result[4], 5.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = LINEARREG(_A, timeperiod=14)
+        assert np.all(np.isnan(result[:13]))
+
+    def test_length(self):
+        assert len(LINEARREG(_A, 14)) == N
+
+    def test_matches_naive_regression(self):
+        expected = _naive_linearreg(_A, timeperiod=14, x_value=13.0)
+        result = LINEARREG(_A, timeperiod=14)
+        np.testing.assert_allclose(result, expected, equal_nan=True)
+
+
+# ---------------------------------------------------------------------------
+# LINEARREG_SLOPE
+# ---------------------------------------------------------------------------
+
+
+class TestLINEARREG_SLOPE:
+    def test_perfect_line_slope_one(self):
+        result = LINEARREG_SLOPE(LINDATA, timeperiod=5)
+        np.testing.assert_allclose(result[4], 1.0, rtol=1e-10)
+
+    def test_constant_slope_zero(self):
+        result = LINEARREG_SLOPE(CONSTDATA, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, 0.0, atol=1e-10)
+
+    def test_length(self):
+        assert len(LINEARREG_SLOPE(_A, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# LINEARREG_INTERCEPT
+# ---------------------------------------------------------------------------
+
+
+class TestLINEARREG_INTERCEPT:
+    def test_perfect_line_intercept_one(self):
+        # y = [1,2,3,4,5] with x=[0,1,2,3,4] → y = 1 + 1*x → intercept = 1.0
+        result = LINEARREG_INTERCEPT(LINDATA, timeperiod=5)
+        np.testing.assert_allclose(result[4], 1.0, atol=1e-10)
+
+    def test_length(self):
+        assert len(LINEARREG_INTERCEPT(_A, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# LINEARREG_ANGLE
+# ---------------------------------------------------------------------------
+
+
+class TestLINEARREG_ANGLE:
+    def test_slope_one_gives_45_degrees(self):
+        result = LINEARREG_ANGLE(LINDATA, timeperiod=5)
+        # arctan(1) * 180/pi = 45
+        np.testing.assert_allclose(result[4], 45.0, rtol=1e-6)
+
+    def test_constant_gives_zero_degrees(self):
+        result = LINEARREG_ANGLE(CONSTDATA, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, 0.0, atol=1e-8)
+
+    def test_length(self):
+        assert len(LINEARREG_ANGLE(_A, 14)) == N
+
+
+# ---------------------------------------------------------------------------
+# BETA
+# ---------------------------------------------------------------------------
+
+
+class TestBETA:
+    def test_nan_warmup(self):
+        result = BETA(_A, _B, timeperiod=5)
+        assert np.all(np.isnan(result[:4]))
+
+    def test_length(self):
+        assert len(BETA(_A, _B, 5)) == N
+
+    def test_same_series(self):
+        # Beta of x vs x = 1.0 (regression of itself)
+        result = BETA(_A, _A, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+    def test_finite_after_warmup(self):
+        result = BETA(_A, _B, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+    def test_matches_naive_beta(self):
+        expected = _naive_beta(_A, _B, timeperiod=5)
+        result = BETA(_A, _B, timeperiod=5)
+        np.testing.assert_allclose(result, expected, equal_nan=True)
+
+
+# ---------------------------------------------------------------------------
+# CORREL
+# ---------------------------------------------------------------------------
+
+
+class TestCOREL:
+    def test_self_correlation_is_one(self):
+        result = CORREL(_A, _A, timeperiod=10)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, 1.0, atol=1e-10)
+
+    def test_opposite_correlation_is_minus_one(self):
+        arr = np.arange(1.0, 11.0)
+        result = CORREL(arr, arr[::-1], timeperiod=5)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid, -1.0, atol=1e-10)
+
+    def test_range(self):
+        result = CORREL(_A, _B, timeperiod=10)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= -1 - 1e-10) and np.all(valid <= 1 + 1e-10)
+
+    def test_length(self):
+        assert len(CORREL(_A, _B, 10)) == N
+
+    def test_matches_naive_correlation(self):
+        expected = _naive_correl(_A, _B, timeperiod=10)
+        result = CORREL(_A, _B, timeperiod=10)
+        np.testing.assert_allclose(result, expected, equal_nan=True)
+
+
+# ---------------------------------------------------------------------------
+# TSF
+# ---------------------------------------------------------------------------
+
+
+class TestTSF:
+    def test_perfect_line(self):
+        arr = np.arange(1.0, 10.0)
+        result = TSF(arr, timeperiod=3)
+        # TSF(3) on [1,2,...] = linear forecast one period ahead
+        # Over window [1,2,3]: slope=1, intercept=0 → forecast at bar 2+1=3 → TSF[2]=4
+        np.testing.assert_allclose(result[2], 4.0, rtol=1e-10)
+        np.testing.assert_allclose(result[3], 5.0, rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = TSF(_A, timeperiod=14)
+        assert np.all(np.isnan(result[:13]))
+
+    def test_length(self):
+        assert len(TSF(_A, 14)) == N
+
+    def test_matches_naive_tsf(self):
+        expected = _naive_linearreg(_A, timeperiod=14, x_value=14.0)
+        result = TSF(_A, timeperiod=14)
+        np.testing.assert_allclose(result, expected, equal_nan=True)
+
+
+# ---------------------------------------------------------------------------
+# DTW — Dynamic Time Warping
+# ---------------------------------------------------------------------------
+
+dtai = pytest.importorskip("dtaidistance", reason="dtaidistance not installed")
+
+_DTW_RNG = np.random.default_rng(42)
+
+
+class TestDTW:
+    # --- Validation against dtaidistance (SOTA reference) ---
+
+    def test_distance_matches_dtaidistance_random(self):
+        """Core correctness: our distance == dtaidistance on 20 random pairs."""
+        for _ in range(20):
+            n = int(_DTW_RNG.integers(5, 50))
+            a = _DTW_RNG.random(n)
+            b = _DTW_RNG.random(n)
+            expected = dtai.dtw.distance(a, b)
+            actual = DTW_DISTANCE(a, b)
+            np.testing.assert_allclose(
+                actual, expected, rtol=1e-9, err_msg=f"Mismatch on series length {n}"
+            )
+
+    def test_distance_matches_dtaidistance_unequal_length(self):
+        """Handles unequal-length series correctly."""
+        for _ in range(10):
+            a = _DTW_RNG.random(int(_DTW_RNG.integers(5, 30)))
+            b = _DTW_RNG.random(int(_DTW_RNG.integers(5, 30)))
+            expected = dtai.dtw.distance(a, b)
+            actual = DTW_DISTANCE(a, b)
+            np.testing.assert_allclose(actual, expected, rtol=1e-9)
+
+    def test_path_distance_matches_dtaidistance(self):
+        """DTW() path variant: returned distance matches dtaidistance."""
+        a = _DTW_RNG.random(20)
+        b = _DTW_RNG.random(25)
+        expected = dtai.dtw.distance(a, b)
+        dist, _ = DTW(a, b)
+        np.testing.assert_allclose(dist, expected, rtol=1e-9)
+
+    def test_path_matches_dtaidistance_warping_path(self):
+        """Warping path matches dtaidistance.dtw.warping_path() on same-length series."""
+        for _ in range(10):
+            n = int(_DTW_RNG.integers(5, 20))
+            a = _DTW_RNG.random(n)
+            b = _DTW_RNG.random(n)
+            expected_path = dtai.dtw.warping_path(a, b)
+            _, actual_path = DTW(a, b)
+            actual_pairs = [tuple(int(x) for x in row) for row in actual_path]
+            assert actual_pairs == expected_path, (
+                f"Path mismatch for n={n}:\n  ours={actual_pairs}\n  dtai={expected_path}"
+            )
+
+    def test_window_constrained_matches_dtaidistance(self):
+        """Sakoe-Chiba window matches dtaidistance window parameter."""
+        a = _DTW_RNG.random(30)
+        b = _DTW_RNG.random(30)
+        for w in [3, 8, 15]:
+            expected = dtai.dtw.distance(a, b, window=w)
+            actual = DTW_DISTANCE(a, b, window=w)
+            np.testing.assert_allclose(
+                actual, expected, rtol=1e-9, err_msg=f"Mismatch at window={w}"
+            )
+
+    def test_batch_matches_dtaidistance(self):
+        """BATCH_DTW matches calling dtaidistance per-row."""
+        ref = _DTW_RNG.random(20)
+        matrix = _DTW_RNG.random((8, 20))
+        batch_result = BATCH_DTW(matrix, ref)
+        for i in range(8):
+            expected = dtai.dtw.distance(matrix[i], ref)
+            np.testing.assert_allclose(
+                batch_result[i],
+                expected,
+                rtol=1e-9,
+                err_msg=f"Batch mismatch at row {i}",
+            )
+
+    # --- Mathematical properties ---
+
+    def test_identical_distance_is_zero(self):
+        a = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        dist, _ = DTW(a, a)
+        assert dist == pytest.approx(0.0, abs=1e-10)
+
+    def test_symmetry(self):
+        a, b = _DTW_RNG.random(20), _DTW_RNG.random(20)
+        assert DTW_DISTANCE(a, b) == pytest.approx(DTW_DISTANCE(b, a), rel=1e-10)
+
+    def test_triangle_inequality(self):
+        a, b, c = _DTW_RNG.random(15), _DTW_RNG.random(15), _DTW_RNG.random(15)
+        assert DTW_DISTANCE(a, c) <= DTW_DISTANCE(a, b) + DTW_DISTANCE(b, c) + 1e-9
+
+    # --- Known hardcoded values ---
+
+    def test_known_shifted_series(self):
+        # [0,1,2] vs [1,2,3]: optimal path (0,0)→(1,0)→(2,1)→(2,2)
+        # Squared costs: 1+0+0+1=2, sqrt(2). Verified against dtaidistance.
+        a = np.array([0.0, 1.0, 2.0])
+        b = np.array([1.0, 2.0, 3.0])
+        np.testing.assert_allclose(DTW_DISTANCE(a, b), np.sqrt(2.0), rtol=1e-9)
+
+    def test_known_single_element(self):
+        # sqrt((3-7)^2) = sqrt(16) = 4.0
+        np.testing.assert_allclose(
+            DTW_DISTANCE(np.array([3.0]), np.array([7.0])), 4.0, rtol=1e-9
+        )
+
+    def test_known_constant_series(self):
+        assert DTW_DISTANCE(np.full(10, 5.0), np.full(10, 5.0)) == pytest.approx(
+            0.0, abs=1e-12
+        )
+
+    # --- Path structural guarantees ---
+
+    def test_path_starts_at_origin(self):
+        _, path = DTW(_DTW_RNG.random(10), _DTW_RNG.random(10))
+        assert tuple(int(x) for x in path[0]) == (0, 0)
+
+    def test_path_ends_at_corner(self):
+        _, path = DTW(_DTW_RNG.random(7), _DTW_RNG.random(9))
+        assert tuple(int(x) for x in path[-1]) == (6, 8)
+
+    def test_path_is_monotone(self):
+        _, path = DTW(_DTW_RNG.random(20), _DTW_RNG.random(20))
+        for k in range(1, len(path)):
+            assert path[k][0] >= path[k - 1][0]
+            assert path[k][1] >= path[k - 1][1]
+
+    def test_path_steps_unit_size(self):
+        _, path = DTW(_DTW_RNG.random(15), _DTW_RNG.random(12))
+        for k in range(1, len(path)):
+            di = int(path[k][0]) - int(path[k - 1][0])
+            dj = int(path[k][1]) - int(path[k - 1][1])
+            assert di in (0, 1) and dj in (0, 1)
+            assert not (di == 0 and dj == 0)
+
+    # --- DTW_DISTANCE == DTW distance ---
+
+    def test_distance_only_matches_full(self):
+        a, b = _DTW_RNG.random(25), _DTW_RNG.random(25)
+        d_full, _ = DTW(a, b)
+        np.testing.assert_allclose(DTW_DISTANCE(a, b), d_full, rtol=1e-10)
+
+    # --- Batch ---
+
+    def test_batch_single_row(self):
+        ref = np.array([1.0, 2.0, 3.0])
+        result = BATCH_DTW(np.array([[1.0, 2.0, 3.0]]), ref)
+        assert result[0] == pytest.approx(0.0, abs=1e-10)
+
+    def test_batch_matches_single_calls(self):
+        ref = _DTW_RNG.random(20)
+        matrix = _DTW_RNG.random((8, 20))
+        batch = BATCH_DTW(matrix, ref)
+        for i in range(8):
+            np.testing.assert_allclose(
+                batch[i], DTW_DISTANCE(matrix[i], ref), rtol=1e-10
+            )
+
+    # --- Edge cases ---
+
+    def test_empty_series_raises(self):
+        with pytest.raises((ValueError, Exception)):
+            DTW(np.array([]), np.array([1.0, 2.0]))
+
+    def test_window_constrained_ge_unconstrained(self):
+        a, b = _DTW_RNG.random(20), _DTW_RNG.random(20)
+        d_full = DTW_DISTANCE(a, b)
+        d_narrow = DTW_DISTANCE(a, b, window=2)
+        assert d_narrow >= d_full - 1e-9

ferro-ta-main/tests/unit/indicators/test_volatility.py

@@ -0,0 +1,125 @@
+"""Unit tests for ferro_ta.indicators.volatility"""
+
+import numpy as np
+
+from ferro_ta.indicators.volatility import ATR, NATR, TRANGE
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(3)
+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))
+
+# Simple 5-bar data with constant range
+SMALL_H = np.array([12.0, 13.0, 14.0, 15.0, 16.0])
+SMALL_L = np.array([9.0, 10.0, 11.0, 12.0, 13.0])
+SMALL_C = np.array([11.0, 12.0, 13.0, 14.0, 15.0])
+
+
+# ---------------------------------------------------------------------------
+# TRANGE
+# ---------------------------------------------------------------------------
+
+
+class TestTRANGE:
+    def test_known_values_constant_range(self):
+        result = TRANGE(SMALL_H, SMALL_L, SMALL_C)
+        # First bar: only high-low = 3 (no prior close)
+        np.testing.assert_allclose(result[0], 3.0, rtol=1e-10)
+        np.testing.assert_allclose(result[1], 3.0, rtol=1e-10)
+
+    def test_no_nan(self):
+        result = TRANGE(SMALL_H, SMALL_L, SMALL_C)
+        assert np.all(np.isfinite(result))
+
+    def test_always_positive(self):
+        result = TRANGE(_HIGH, _LOW, _CLOSE)
+        assert np.all(result > 0)
+
+    def test_length(self):
+        assert len(TRANGE(_HIGH, _LOW, _CLOSE)) == N
+
+    def test_formula_first_bar(self):
+        h = np.array([15.0, 16.0, 17.0])
+        l = np.array([10.0, 11.0, 12.0])
+        c = np.array([13.0, 14.0, 15.0])
+        result = TRANGE(h, l, c)
+        # bar 0: TRANGE = h[0] - l[0] = 5
+        np.testing.assert_allclose(result[0], 5.0, rtol=1e-10)
+        # bar 1: max(h[1]-l[1], |h[1]-c[0]|, |l[1]-c[0]|)
+        #      = max(5, |16-13|, |11-13|) = max(5, 3, 2) = 5
+        np.testing.assert_allclose(result[1], 5.0, rtol=1e-10)
+
+    def test_with_gap(self):
+        # Gap up: prev close=10, curr high=20, curr low=15
+        h = np.array([10.0, 20.0])
+        l = np.array([8.0, 15.0])
+        c = np.array([10.0, 18.0])
+        result = TRANGE(h, l, c)
+        # bar 1: max(20-15, |20-10|, |15-10|) = max(5, 10, 5) = 10
+        np.testing.assert_allclose(result[1], 10.0, rtol=1e-10)
+
+
+# ---------------------------------------------------------------------------
+# ATR
+# ---------------------------------------------------------------------------
+
+
+class TestATR:
+    def test_timeperiod_1_equals_trange(self):
+        atr = ATR(SMALL_H, SMALL_L, SMALL_C, timeperiod=1)
+        trange = TRANGE(SMALL_H, SMALL_L, SMALL_C)
+        # ATR(1) first bar is NaN, subsequent equal TRANGE
+        np.testing.assert_allclose(atr[1:], trange[1:], rtol=1e-10)
+
+    def test_nan_warmup(self):
+        result = ATR(_HIGH, _LOW, _CLOSE, timeperiod=14)
+        assert np.all(np.isnan(result[:14]))
+
+    def test_length(self):
+        assert len(ATR(_HIGH, _LOW, _CLOSE, 14)) == N
+
+    def test_always_positive(self):
+        result = ATR(_HIGH, _LOW, _CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid > 0)
+
+    def test_constant_range_converges(self):
+        # Constant TRANGE=3 → ATR should converge to 3
+        h = np.full(100, 12.0) + np.arange(100) * 0.0
+        l = np.full(100, 9.0) + np.arange(100) * 0.0
+        c = np.full(100, 11.0) + np.arange(100) * 0.0
+        result = ATR(h, l, c, timeperiod=5)
+        valid = result[~np.isnan(result)]
+        np.testing.assert_allclose(valid[-1], 3.0, atol=0.01)
+
+
+# ---------------------------------------------------------------------------
+# NATR
+# ---------------------------------------------------------------------------
+
+
+class TestNATR:
+    def test_nan_warmup(self):
+        result = NATR(_HIGH, _LOW, _CLOSE, timeperiod=14)
+        assert np.all(np.isnan(result[:14]))
+
+    def test_length(self):
+        assert len(NATR(_HIGH, _LOW, _CLOSE, 14)) == N
+
+    def test_positive(self):
+        result = NATR(_HIGH, _LOW, _CLOSE, 14)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid > 0)
+
+    def test_relation_to_atr(self):
+        # NATR = ATR / close * 100
+        atr = ATR(_HIGH, _LOW, _CLOSE, 14)
+        natr = NATR(_HIGH, _LOW, _CLOSE, 14)
+        valid = ~np.isnan(atr) & ~np.isnan(natr)
+        expected = atr[valid] / _CLOSE[valid] * 100
+        np.testing.assert_allclose(natr[valid], expected, rtol=1e-5)

ferro-ta-main/tests/unit/indicators/test_volume.py

@@ -0,0 +1,118 @@
+"""Unit tests for ferro_ta.indicators.volume"""
+
+import numpy as np
+
+from ferro_ta.indicators.volume import AD, ADOSC, OBV
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(5)
+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))
+_VOL = RNG.uniform(1000, 5000, N)
+
+SMALL_H = np.array([12.0, 13.0, 14.0, 15.0, 16.0])
+SMALL_L = np.array([9.0, 10.0, 11.0, 12.0, 13.0])
+SMALL_C = np.array([11.0, 12.0, 13.0, 14.0, 15.0])
+SMALL_V = np.array([1000.0, 2000.0, 3000.0, 4000.0, 5000.0])
+
+
+# ---------------------------------------------------------------------------
+# OBV
+# ---------------------------------------------------------------------------
+
+
+class TestOBV:
+    def test_known_values_rising(self):
+        # Rising close: OBV accumulates all volume
+        c = np.array([10.0, 11.0, 12.0, 13.0, 14.0])
+        v = np.array([1000.0, 1000.0, 1000.0, 1000.0, 1000.0])
+        result = OBV(c, v)
+        np.testing.assert_allclose(result[0], 0.0, atol=1e-10)
+        np.testing.assert_allclose(result[1], 1000.0, atol=1e-10)
+        np.testing.assert_allclose(result[4], 4000.0, atol=1e-10)
+
+    def test_known_values_falling(self):
+        c = np.array([14.0, 13.0, 12.0, 11.0, 10.0])
+        v = np.array([1000.0, 1000.0, 1000.0, 1000.0, 1000.0])
+        result = OBV(c, v)
+        np.testing.assert_allclose(result[0], 0.0, atol=1e-10)
+        np.testing.assert_allclose(result[1], -1000.0, atol=1e-10)
+        np.testing.assert_allclose(result[4], -4000.0, atol=1e-10)
+
+    def test_unchanged_price_no_change(self):
+        c = np.array([10.0, 10.0, 10.0])
+        v = np.array([500.0, 500.0, 500.0])
+        result = OBV(c, v)
+        np.testing.assert_allclose(result, [0.0, 0.0, 0.0], atol=1e-10)
+
+    def test_no_nan(self):
+        result = OBV(SMALL_C, SMALL_V)
+        assert np.all(np.isfinite(result))
+
+    def test_length(self):
+        assert len(OBV(_CLOSE, _VOL)) == N
+
+    def test_starts_zero(self):
+        result = OBV(_CLOSE, _VOL)
+        np.testing.assert_allclose(result[0], 0.0, atol=1e-10)
+
+
+# ---------------------------------------------------------------------------
+# AD
+# ---------------------------------------------------------------------------
+
+
+class TestAD:
+    def test_known_formula(self):
+        # AD = cumsum(CLV * volume)
+        # CLV = ((close - low) - (high - close)) / (high - low)
+        h = np.array([15.0])
+        l = np.array([10.0])
+        c = np.array([12.0])
+        v = np.array([1000.0])
+        clv = ((12 - 10) - (15 - 12)) / (15 - 10)  # (2 - 3) / 5 = -0.2
+        expected = clv * 1000.0
+        result = AD(h, l, c, v)
+        np.testing.assert_allclose(result[0], expected, rtol=1e-10)
+
+    def test_monotone_rising_positive(self):
+        # High CLV on rising data → AD should be non-negative cumulatively
+        result = AD(SMALL_H, SMALL_L, SMALL_C, SMALL_V)
+        assert np.all(np.isfinite(result))
+
+    def test_no_nan(self):
+        result = AD(_HIGH, _LOW, _CLOSE, _VOL)
+        assert np.all(np.isfinite(result))
+
+    def test_length(self):
+        assert len(AD(_HIGH, _LOW, _CLOSE, _VOL)) == N
+
+
+# ---------------------------------------------------------------------------
+# ADOSC
+# ---------------------------------------------------------------------------
+
+
+class TestADOSC:
+    def test_nan_warmup(self):
+        result = ADOSC(_HIGH, _LOW, _CLOSE, _VOL, fastperiod=3, slowperiod=10)
+        assert np.all(np.isnan(result[:9]))
+
+    def test_length(self):
+        assert len(ADOSC(_HIGH, _LOW, _CLOSE, _VOL, 3, 10)) == N
+
+    def test_finite_after_warmup(self):
+        result = ADOSC(_HIGH, _LOW, _CLOSE, _VOL, fastperiod=3, slowperiod=10)
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+    def test_known_values(self):
+        result = ADOSC(SMALL_H, SMALL_L, SMALL_C, SMALL_V, fastperiod=2, slowperiod=3)
+        valid = result[~np.isnan(result)]
+        assert len(valid) > 0
+        assert np.all(np.isfinite(valid))

ferro-ta-main/tests/unit/streaming/test_streaming.py

@@ -0,0 +1,387 @@
+"""Tests for ferro_ta streaming / incremental indicators."""
+
+import math
+
+import numpy as np
+import pytest
+
+from ferro_ta import EMA, RSI, SMA
+from ferro_ta.data.streaming import StreamingEMA, StreamingRSI, StreamingSMA
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+PRICES = np.array(
+    [
+        44.34,
+        44.09,
+        44.15,
+        43.61,
+        44.33,
+        44.83,
+        45.10,
+        45.15,
+        43.61,
+        44.33,
+        44.83,
+        45.10,
+        45.15,
+        43.61,
+        44.33,
+    ],
+    dtype=np.float64,
+)
+
+
+def _finite(arr: np.ndarray) -> np.ndarray:
+    return arr[~np.isnan(arr)]
+
+
+# ---------------------------------------------------------------------------
+# StreamingSMA
+# ---------------------------------------------------------------------------
+
+
+class TestStreamingSMA:
+    def test_basic_values(self):
+        """Feed known values, verify manually computed SMA."""
+        sma = StreamingSMA(period=3)
+        assert math.isnan(sma.update(1.0))
+        assert math.isnan(sma.update(2.0))
+        assert math.isclose(sma.update(3.0), 2.0)
+        assert math.isclose(sma.update(4.0), 3.0)
+        assert math.isclose(sma.update(5.0), 4.0)
+
+    def test_matches_batch_sma(self):
+        """Streaming SMA final values must match batch SMA on the same data."""
+        period = 5
+        batch = SMA(PRICES, timeperiod=period)
+        sma = StreamingSMA(period=period)
+        for i, price in enumerate(PRICES):
+            val = sma.update(price)
+            if math.isnan(batch[i]):
+                assert math.isnan(val), f"Expected NaN at index {i}"
+            else:
+                assert math.isclose(val, batch[i], rel_tol=1e-10), (
+                    f"Mismatch at index {i}: streaming={val}, batch={batch[i]}"
+                )
+
+    def test_period_property(self):
+        sma = StreamingSMA(period=7)
+        assert sma.period == 7
+
+    def test_warmup_returns_nan(self):
+        """First period-1 updates must return NaN."""
+        period = 4
+        sma = StreamingSMA(period=period)
+        for i in range(period - 1):
+            assert math.isnan(sma.update(float(i + 1)))
+        # The period-th update should NOT be NaN
+        assert not math.isnan(sma.update(float(period)))
+
+    def test_single_value_period_1(self):
+        """Period=1 means every value is immediately returned."""
+        sma = StreamingSMA(period=1)
+        assert math.isclose(sma.update(42.0), 42.0)
+        assert math.isclose(sma.update(99.0), 99.0)
+
+    def test_reset(self):
+        """After reset, the indicator should behave as freshly constructed."""
+        sma = StreamingSMA(period=3)
+        sma.update(10.0)
+        sma.update(20.0)
+        result_before_reset = sma.update(30.0)
+        assert math.isclose(result_before_reset, 20.0)
+
+        sma.reset()
+        # After reset, warmup restarts
+        assert math.isnan(sma.update(100.0))
+        assert math.isnan(sma.update(200.0))
+        assert math.isclose(sma.update(300.0), 200.0)
+
+    def test_invalid_period_zero(self):
+        with pytest.raises(Exception):
+            StreamingSMA(period=0)
+
+    def test_repr(self):
+        sma = StreamingSMA(period=5)
+        assert "StreamingSMA" in repr(sma)
+        assert "5" in repr(sma)
+
+
+# ---------------------------------------------------------------------------
+# StreamingEMA
+# ---------------------------------------------------------------------------
+
+
+class TestStreamingEMA:
+    def test_basic_seeding(self):
+        """EMA seeds from the first `period` values using their SMA."""
+        ema = StreamingEMA(period=3)
+        assert math.isnan(ema.update(1.0))
+        assert math.isnan(ema.update(2.0))
+        # Seed = SMA(1,2,3) = 2.0
+        seed = ema.update(3.0)
+        assert math.isclose(seed, 2.0)
+
+    def test_matches_batch_ema(self):
+        """Streaming EMA must match batch EMA on the same data."""
+        period = 5
+        batch = EMA(PRICES, timeperiod=period)
+        ema = StreamingEMA(period=period)
+        for i, price in enumerate(PRICES):
+            val = ema.update(price)
+            if math.isnan(batch[i]):
+                assert math.isnan(val), f"Expected NaN at index {i}"
+            else:
+                assert math.isclose(val, batch[i], rel_tol=1e-10), (
+                    f"Mismatch at index {i}: streaming={val}, batch={batch[i]}"
+                )
+
+    def test_warmup_returns_nan(self):
+        period = 5
+        ema = StreamingEMA(period=period)
+        for i in range(period - 1):
+            assert math.isnan(ema.update(float(i + 1)))
+        assert not math.isnan(ema.update(float(period)))
+
+    def test_ema_differs_from_sma_after_warmup(self):
+        """After warmup, EMA and SMA should diverge for non-constant data."""
+        period = 3
+        prices = [1.0, 2.0, 3.0, 10.0, 11.0]
+        sma = StreamingSMA(period=period)
+        ema = StreamingEMA(period=period)
+        sma_vals = [sma.update(p) for p in prices]
+        ema_vals = [ema.update(p) for p in prices]
+        # At the seed point they should match (both are SMA of first 3)
+        assert math.isclose(sma_vals[2], ema_vals[2])
+        # After the seed they should diverge
+        assert not math.isclose(sma_vals[-1], ema_vals[-1], rel_tol=1e-9)
+
+    def test_reset(self):
+        ema = StreamingEMA(period=3)
+        for p in [10.0, 20.0, 30.0, 40.0]:
+            ema.update(p)
+        ema.reset()
+        # After reset, warmup restarts
+        assert math.isnan(ema.update(1.0))
+        assert math.isnan(ema.update(2.0))
+        assert math.isclose(ema.update(3.0), 2.0)
+
+    def test_period_property(self):
+        ema = StreamingEMA(period=10)
+        assert ema.period == 10
+
+    def test_invalid_period_zero(self):
+        with pytest.raises(Exception):
+            StreamingEMA(period=0)
+
+    def test_single_value_period_1(self):
+        ema = StreamingEMA(period=1)
+        assert math.isclose(ema.update(42.0), 42.0)
+        assert math.isclose(ema.update(50.0), 50.0)
+
+    def test_repr(self):
+        ema = StreamingEMA(period=12)
+        assert "StreamingEMA" in repr(ema)
+        assert "12" in repr(ema)
+
+
+# ---------------------------------------------------------------------------
+# StreamingRSI
+# ---------------------------------------------------------------------------
+
+
+class TestStreamingRSI:
+    def test_matches_batch_rsi(self):
+        """Streaming RSI must match batch RSI on the same data."""
+        period = 5
+        batch = RSI(PRICES, timeperiod=period)
+        rsi = StreamingRSI(period=period)
+        for i, price in enumerate(PRICES):
+            val = rsi.update(price)
+            if math.isnan(batch[i]):
+                assert math.isnan(val), f"Expected NaN at index {i}"
+            else:
+                assert math.isclose(val, batch[i], rel_tol=1e-8), (
+                    f"Mismatch at index {i}: streaming={val}, batch={batch[i]}"
+                )
+
+    def test_warmup_returns_nan(self):
+        """RSI needs period+1 bars (1 for first prev, then period deltas)."""
+        period = 5
+        rsi = StreamingRSI(period=period)
+        # First bar: sets prev, returns NaN
+        assert math.isnan(rsi.update(50.0))
+        # Next period-1 bars: accumulating deltas, returns NaN
+        for i in range(period - 1):
+            assert math.isnan(rsi.update(50.0 + i))
+        # The (period+1)-th bar should produce a value
+        assert not math.isnan(rsi.update(55.0))
+
+    def test_rsi_range(self):
+        """All finite RSI values must be in [0, 100]."""
+        rsi = StreamingRSI(period=5)
+        for price in PRICES:
+            val = rsi.update(price)
+            if not math.isnan(val):
+                assert 0.0 <= val <= 100.0, f"RSI out of range: {val}"
+
+    def test_constant_prices(self):
+        """Constant prices produce no gains or losses -- RSI should be 100
+        (avg_loss == 0 leads to RS = infinity -> RSI = 100)."""
+        rsi = StreamingRSI(period=5)
+        results = [rsi.update(50.0) for _ in range(20)]
+        finite = [v for v in results if not math.isnan(v)]
+        assert len(finite) > 0
+        for v in finite:
+            assert math.isclose(v, 100.0) or math.isclose(v, 0.0) or (0.0 <= v <= 100.0)
+
+    def test_monotone_increasing(self):
+        """Monotonically increasing prices should yield RSI = 100."""
+        rsi = StreamingRSI(period=3)
+        results = [rsi.update(float(i)) for i in range(1, 20)]
+        finite = [v for v in results if not math.isnan(v)]
+        for v in finite:
+            assert math.isclose(v, 100.0), (
+                f"Expected RSI=100 for monotone increase, got {v}"
+            )
+
+    def test_monotone_decreasing(self):
+        """Monotonically decreasing prices should yield RSI = 0."""
+        rsi = StreamingRSI(period=3)
+        results = [rsi.update(float(100 - i)) for i in range(20)]
+        finite = [v for v in results if not math.isnan(v)]
+        for v in finite:
+            assert math.isclose(v, 0.0, abs_tol=1e-10), (
+                f"Expected RSI=0 for monotone decrease, got {v}"
+            )
+
+    def test_default_period_14(self):
+        rsi = StreamingRSI()
+        assert rsi.period == 14
+
+    def test_reset(self):
+        rsi = StreamingRSI(period=3)
+        for price in PRICES:
+            rsi.update(price)
+        rsi.reset()
+        # After reset, warmup restarts -- first update should be NaN
+        assert math.isnan(rsi.update(50.0))
+
+    def test_invalid_period_zero(self):
+        with pytest.raises(Exception):
+            StreamingRSI(period=0)
+
+    def test_repr(self):
+        rsi = StreamingRSI(period=14)
+        assert "StreamingRSI" in repr(rsi)
+        assert "14" in repr(rsi)
+
+
+# ---------------------------------------------------------------------------
+# Edge cases (shared across indicators)
+# ---------------------------------------------------------------------------
+
+
+class TestStreamingEdgeCases:
+    def test_nan_input_sma(self):
+        """Feeding NaN into SMA should propagate NaN through the window."""
+        sma = StreamingSMA(period=3)
+        sma.update(1.0)
+        sma.update(2.0)
+        # Third value is NaN -- the sum will include NaN, producing NaN
+        val = sma.update(float("nan"))
+        assert math.isnan(val)
+
+    def test_nan_input_ema(self):
+        """Feeding NaN into EMA should produce NaN output."""
+        ema = StreamingEMA(period=3)
+        ema.update(1.0)
+        ema.update(2.0)
+        val = ema.update(float("nan"))
+        assert math.isnan(val)
+
+    def test_nan_input_rsi(self):
+        """Feeding NaN into RSI should produce NaN output."""
+        rsi = StreamingRSI(period=3)
+        rsi.update(1.0)
+        rsi.update(2.0)
+        val = rsi.update(float("nan"))
+        assert math.isnan(val)
+
+    def test_single_value_sma(self):
+        """Feeding exactly one value to SMA with period > 1 yields NaN."""
+        sma = StreamingSMA(period=5)
+        assert math.isnan(sma.update(42.0))
+
+    def test_single_value_ema(self):
+        ema = StreamingEMA(period=5)
+        assert math.isnan(ema.update(42.0))
+
+    def test_single_value_rsi(self):
+        rsi = StreamingRSI(period=5)
+        assert math.isnan(rsi.update(42.0))
+
+    def test_large_dataset_sma(self):
+        """Ensure streaming SMA is stable over many updates."""
+        period = 20
+        sma = StreamingSMA(period=period)
+        np.random.seed(42)
+        data = np.random.randn(10_000).cumsum() + 100.0
+        batch = SMA(data, timeperiod=period)
+        for i, price in enumerate(data):
+            val = sma.update(price)
+            if not math.isnan(batch[i]):
+                assert math.isclose(val, batch[i], rel_tol=1e-8), (
+                    f"Drift at index {i}: streaming={val}, batch={batch[i]}"
+                )
+
+    def test_large_dataset_ema(self):
+        """Ensure streaming EMA is stable over many updates."""
+        period = 20
+        ema = StreamingEMA(period=period)
+        np.random.seed(42)
+        data = np.random.randn(10_000).cumsum() + 100.0
+        batch = EMA(data, timeperiod=period)
+        for i, price in enumerate(data):
+            val = ema.update(price)
+            if not math.isnan(batch[i]):
+                assert math.isclose(val, batch[i], rel_tol=1e-8), (
+                    f"Drift at index {i}: streaming={val}, batch={batch[i]}"
+                )
+
+    def test_large_dataset_rsi(self):
+        """Ensure streaming RSI is stable over many updates."""
+        period = 14
+        rsi = StreamingRSI(period=period)
+        np.random.seed(42)
+        data = np.random.randn(10_000).cumsum() + 100.0
+        batch = RSI(data, timeperiod=period)
+        for i, price in enumerate(data):
+            val = rsi.update(price)
+            if not math.isnan(batch[i]):
+                assert math.isclose(val, batch[i], rel_tol=1e-6), (
+                    f"Drift at index {i}: streaming={val}, batch={batch[i]}"
+                )
+
+    def test_reset_then_reuse_matches_fresh_instance(self):
+        """A reset indicator should produce identical output to a new one."""
+        period = 5
+        data = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0]
+
+        sma_reused = StreamingSMA(period=period)
+        for p in [99.0, 98.0, 97.0, 96.0, 95.0]:
+            sma_reused.update(p)
+        sma_reused.reset()
+
+        sma_fresh = StreamingSMA(period=period)
+
+        for p in data:
+            v1 = sma_reused.update(p)
+            v2 = sma_fresh.update(p)
+            if math.isnan(v1):
+                assert math.isnan(v2)
+            else:
+                assert math.isclose(v1, v2, rel_tol=1e-12)

ferro-ta-main/tests/unit/test_data_pipeline.py

@@ -0,0 +1,777 @@
+"""Tests for resampling, tick aggregation, DSL, signals,
+portfolio analytics, cross-asset analytics, feature matrix, viz, and adapters.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+# ---------------------------------------------------------------------------
+# Synthetic helpers
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(2024)
+
+
+def _make_ohlcv(n: int = 100):
+    """Return (open, high, low, close, volume) as numpy arrays."""
+    close = np.cumprod(1 + RNG.normal(0, 0.01, n)) * 100.0
+    open_ = close * RNG.uniform(0.995, 1.005, n)
+    high = np.maximum(close, open_) + RNG.uniform(0, 0.5, n)
+    low = np.minimum(close, open_) - RNG.uniform(0, 0.5, n)
+    volume = RNG.uniform(500, 5000, n)
+    return open_, high, low, close, volume
+
+
+def _make_ticks(n: int = 500):
+    price = 100.0 + np.cumsum(RNG.normal(0, 0.05, n))
+    size = RNG.uniform(10, 100, n)
+    return price, size
+
+
+# ---------------------------------------------------------------------------
+# Resampling
+# ---------------------------------------------------------------------------
+
+
+class TestVolumeBarResampling:
+    """Rust-backed volume_bars function."""
+
+    def test_returns_five_arrays(self):
+        from ferro_ta.data.resampling import volume_bars
+
+        o, h, l, c, v = _make_ohlcv(100)
+        bars = volume_bars((o, h, l, c, v), volume_threshold=2000)
+        assert len(bars) == 5
+        assert all(isinstance(b, np.ndarray) for b in bars)
+
+    def test_volume_bars_reduce_length(self):
+        from ferro_ta.data.resampling import volume_bars
+
+        o, h, l, c, v = _make_ohlcv(200)
+        bars = volume_bars((o, h, l, c, v), volume_threshold=5000)
+        # Output should have fewer bars than input
+        assert len(bars[0]) < 200
+
+    def test_each_bar_high_ge_low(self):
+        from ferro_ta.data.resampling import volume_bars
+
+        o, h, l, c, v = _make_ohlcv(100)
+        ro, rh, rl, rc, rv = volume_bars((o, h, l, c, v), volume_threshold=2000)
+        assert np.all(rh >= rl)
+
+    def test_output_volume_ge_threshold(self):
+        from ferro_ta.data.resampling import volume_bars
+
+        o, h, l, c, v = _make_ohlcv(100)
+        threshold = 1500.0
+        _, _, _, _, rv = volume_bars((o, h, l, c, v), volume_threshold=threshold)
+        # All but the last bar should satisfy the threshold
+        if len(rv) > 1:
+            assert np.all(rv[:-1] >= threshold)
+
+    def test_invalid_threshold_raises(self):
+        from ferro_ta.data.resampling import volume_bars
+
+        o, h, l, c, v = _make_ohlcv(10)
+        with pytest.raises(Exception):
+            volume_bars((o, h, l, c, v), volume_threshold=-1)
+
+    def test_ohlcv_agg_rust_function(self):
+        from ferro_ta._ferro_ta import ohlcv_agg
+
+        o, h, l, c, v = _make_ohlcv(10)
+        labels = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 2], dtype=np.int64)
+        ro, rh, rl, rc, rv = ohlcv_agg(o, h, l, c, v, labels)
+        assert len(ro) == 3
+
+    def test_resample_with_pandas(self):
+        """Time-based resampling using pandas DatetimeIndex."""
+        pytest.importorskip("pandas")
+        import pandas as pd
+
+        from ferro_ta.data.resampling import resample
+
+        idx = pd.date_range("2024-01-01", periods=60, freq="1min")
+        o, h, l, c, v = _make_ohlcv(60)
+        df = pd.DataFrame(
+            {"open": o, "high": h, "low": l, "close": c, "volume": v},
+            index=idx,
+        )
+        df5 = resample(df, "5min")
+        # 60 1-minute bars → 12 or 13 5-minute bars depending on pandas version/label
+        assert 11 <= len(df5) <= 13
+        assert set(df5.columns) == {"open", "high", "low", "close", "volume"}
+
+    def test_volume_bars_dataframe_return(self):
+        pytest.importorskip("pandas")
+        import pandas as pd
+
+        from ferro_ta.data.resampling import volume_bars
+
+        o, h, l, c, v = _make_ohlcv(60)
+        df = pd.DataFrame({"open": o, "high": h, "low": l, "close": c, "volume": v})
+        result = volume_bars(df, volume_threshold=3000)
+        assert isinstance(result, pd.DataFrame)
+        assert "close" in result.columns
+
+    def test_multi_timeframe_returns_dict(self):
+        pytest.importorskip("pandas")
+        import pandas as pd
+
+        from ferro_ta import RSI
+        from ferro_ta.data.resampling import multi_timeframe
+
+        idx = pd.date_range("2024-01-01", periods=200, freq="1min")
+        o, h, l, c, v = _make_ohlcv(200)
+        df = pd.DataFrame(
+            {"open": o, "high": h, "low": l, "close": c, "volume": v},
+            index=idx,
+        )
+        result = multi_timeframe(
+            df, ["5min", "15min"], indicator=RSI, indicator_kwargs={"timeperiod": 14}
+        )
+        assert sorted(result.keys()) == ["15min", "5min"]
+        for key, arr in result.items():
+            assert isinstance(arr, np.ndarray)
+
+
+# ---------------------------------------------------------------------------
+# Tick aggregation
+# ---------------------------------------------------------------------------
+
+
+class TestTickAggregation:
+    """aggregate_ticks and TickAggregator."""
+
+    def test_tick_bars_dict_input(self):
+        from ferro_ta.data.aggregation import aggregate_ticks
+
+        price, size = _make_ticks(500)
+        result = aggregate_ticks({"price": price, "size": size}, rule="tick:50")
+        assert "open" in result
+        # 500 / 50 = 10 bars
+        assert len(result["open"]) == 10
+
+    def test_volume_bars_ticks(self):
+        from ferro_ta.data.aggregation import aggregate_ticks
+
+        price, size = _make_ticks(200)
+        result = aggregate_ticks({"price": price, "size": size}, rule="volume:500")
+        assert len(result["open"]) > 0
+
+    def test_time_bars_ticks(self):
+        from ferro_ta.data.aggregation import aggregate_ticks
+
+        price, size = _make_ticks(300)
+        ts = np.arange(300, dtype=np.float64)  # 1 second intervals
+        result = aggregate_ticks(
+            {"timestamp": ts, "price": price, "size": size}, rule="time:60"
+        )
+        # 300 seconds / 60 = 5 bars
+        assert len(result["open"]) == 5
+
+    def test_tick_aggregator_class(self):
+        from ferro_ta.data.aggregation import TickAggregator
+
+        agg = TickAggregator(rule="tick:50")
+        price, size = _make_ticks(200)
+        result = agg.aggregate({"price": price, "size": size})
+        assert len(result["open"]) == 4  # 200 / 50 = 4
+
+    def test_invalid_rule_raises(self):
+        from ferro_ta.data.aggregation import aggregate_ticks
+
+        price, size = _make_ticks(100)
+        with pytest.raises(ValueError, match="Invalid rule"):
+            aggregate_ticks({"price": price, "size": size}, rule="bad_rule")
+
+    def test_unknown_bar_type_raises(self):
+        from ferro_ta.data.aggregation import aggregate_ticks
+
+        price, size = _make_ticks(100)
+        with pytest.raises(ValueError, match="Unknown bar type"):
+            aggregate_ticks({"price": price, "size": size}, rule="unknown:50")
+
+    def test_tick_bars_indicator_pipeline(self):
+        """Full pipeline: ticks → bars → RSI."""
+        from ferro_ta import RSI
+        from ferro_ta.data.aggregation import aggregate_ticks
+
+        price, size = _make_ticks(1000)
+        bars = aggregate_ticks({"price": price, "size": size}, rule="tick:20")
+        close = np.asarray(bars["close"], dtype=np.float64)
+        rsi = RSI(close, timeperiod=14)
+        assert rsi.shape == close.shape
+
+    def test_list_input(self):
+        from ferro_ta.data.aggregation import aggregate_ticks
+
+        ticks = [(float(i), 100.0 + i * 0.01, 10.0) for i in range(100)]
+        result = aggregate_ticks(ticks, rule="tick:10")
+        assert len(result["open"]) == 10
+
+
+# ---------------------------------------------------------------------------
+# Strategy DSL
+# ---------------------------------------------------------------------------
+
+
+class TestStrategyDSL:
+    def test_parse_simple_expression(self):
+        from ferro_ta.tools.dsl import parse_expression
+
+        ast = parse_expression("RSI(14) < 30")
+        assert ast is not None
+
+    def test_evaluate_returns_int_array(self):
+        from ferro_ta.tools.dsl import evaluate
+
+        close = np.cumprod(1 + RNG.normal(0, 0.01, 100)) * 100
+        sig = evaluate("RSI(14) < 30", {"close": close})
+        assert sig.dtype == np.int32
+        assert sig.shape == (100,)
+        assert set(sig.tolist()).issubset({0, 1})
+
+    def test_evaluate_and_expression(self):
+        from ferro_ta.tools.dsl import evaluate
+
+        close = np.cumprod(1 + RNG.normal(0, 0.01, 100)) * 100
+        sig = evaluate("RSI(14) < 70 and RSI(14) > 30", {"close": close})
+        assert sig.shape == (100,)
+
+    def test_evaluate_or_expression(self):
+        from ferro_ta.tools.dsl import evaluate
+
+        close = np.cumprod(1 + RNG.normal(0, 0.01, 100)) * 100
+        sig = evaluate("RSI(14) < 30 or RSI(14) > 70", {"close": close})
+        assert sig.shape == (100,)
+
+    def test_evaluate_not_expression(self):
+        from ferro_ta.tools.dsl import evaluate
+
+        close = np.cumprod(1 + RNG.normal(0, 0.01, 100)) * 100
+        sig = evaluate("not RSI(14) < 30", {"close": close})
+        assert set(sig.tolist()).issubset({0, 1})
+
+    def test_strategy_class(self):
+        from ferro_ta.tools.dsl import Strategy
+
+        close = np.cumprod(1 + RNG.normal(0, 0.01, 100)) * 100
+        strat = Strategy("RSI(14) < 30")
+        sig = strat.evaluate({"close": close})
+        assert sig.shape == (100,)
+
+    def test_combined_close_sma_expression(self):
+        from ferro_ta.tools.dsl import evaluate
+
+        close = np.cumprod(1 + RNG.normal(0, 0.01, 60)) * 100
+        sig = evaluate("close > SMA(20)", {"close": close})
+        assert sig.shape == (60,)
+
+    def test_invalid_expression_raises(self):
+        from ferro_ta.tools.dsl import parse_expression
+
+        with pytest.raises(ValueError):
+            parse_expression("")
+
+    def test_parse_expression_with_cross_above_placeholder(self):
+        """cross_above tokens parse without error."""
+        from ferro_ta.tools.dsl import parse_expression
+
+        ast = parse_expression("cross_above(close, SMA(20))")
+        assert ast is not None
+
+    def test_backtest_with_dsl_signal(self):
+        """Combine DSL signal with the existing backtest module."""
+        from ferro_ta.analysis.backtest import backtest
+        from ferro_ta.tools.dsl import Strategy
+
+        close = np.cumprod(1 + RNG.normal(0, 0.01, 100)) * 100
+        strat = Strategy("RSI(14) < 30")
+        strat.evaluate({"close": close})  # signal not fed to backtest in this test
+        # Manually feed signal to backtest
+        result = backtest(close, strategy="rsi_30_70")
+        assert result is not None
+
+
+# ---------------------------------------------------------------------------
+# Signal composition and screening
+# ---------------------------------------------------------------------------
+
+
+class TestSignalComposition:
+    def test_compose_weighted(self):
+        from ferro_ta.analysis.signals import compose
+
+        sigs = RNG.standard_normal((50, 3))
+        score = compose(sigs, weights=[0.5, 0.3, 0.2])
+        assert score.shape == (50,)
+
+    def test_compose_mean(self):
+        from ferro_ta.analysis.signals import compose
+
+        sigs = np.ones((10, 4)) * 2.0
+        score = compose(sigs, method="mean")
+        np.testing.assert_allclose(score, 2.0)
+
+    def test_compose_rank(self):
+        from ferro_ta.analysis.signals import compose
+
+        sigs = RNG.standard_normal((30, 3))
+        score = compose(sigs, method="rank")
+        assert score.shape == (30,)
+
+    def test_compose_rank_matches_manual_column_ranks(self):
+        from ferro_ta.analysis.signals import compose
+
+        sigs = np.array(
+            [
+                [3.0, 1.0],
+                [1.0, 2.0],
+                [2.0, 2.0],
+            ],
+            dtype=np.float64,
+        )
+        score = compose(sigs, method="rank")
+        expected = np.array([4.0, 3.5, 4.5], dtype=np.float64)
+        np.testing.assert_allclose(score, expected)
+
+    def test_compose_equal_weights_default(self):
+        from ferro_ta.analysis.signals import compose
+
+        sigs = np.ones((5, 3))
+        score = compose(sigs)  # equal weight by default
+        np.testing.assert_allclose(score, 1.0)
+
+    def test_screen_top_n(self):
+        from ferro_ta.analysis.signals import screen
+
+        scores = {"AAPL": 0.8, "GOOG": 0.5, "MSFT": 0.9, "AMZN": 0.3}
+        result = screen(scores, top_n=2)
+        assert list(result.keys()) == ["MSFT", "AAPL"]
+
+    def test_screen_bottom_n(self):
+        from ferro_ta.analysis.signals import screen
+
+        scores = {"A": 3, "B": 1, "C": 2}
+        result = screen(scores, bottom_n=2)
+        assert list(result.keys()) == ["B", "C"]
+
+    def test_screen_above_threshold(self):
+        from ferro_ta.analysis.signals import screen
+
+        scores = {"A": 0.7, "B": 0.3, "C": 0.9}
+        result = screen(scores, above=0.5)
+        assert set(result.keys()) == {"A", "C"}
+
+    def test_rank_signals(self):
+        from ferro_ta.analysis.signals import rank_signals
+
+        x = np.array([3.0, 1.0, 2.0])
+        r = rank_signals(x)
+        np.testing.assert_allclose(r, [3.0, 1.0, 2.0])
+
+    def test_rank_signals_ties(self):
+        from ferro_ta.analysis.signals import rank_signals
+
+        x = np.array([1.0, 1.0, 3.0])
+        r = rank_signals(x)
+        np.testing.assert_allclose(r[0], 1.5)
+        np.testing.assert_allclose(r[1], 1.5)
+        np.testing.assert_allclose(r[2], 3.0)
+
+    def test_top_n_indices_rust(self):
+        from ferro_ta._ferro_ta import top_n_indices
+
+        x = np.array([1.0, 5.0, 3.0, 7.0, 2.0])
+        idx = top_n_indices(x, 2)
+        vals = sorted(x[i] for i in idx)
+        assert vals == [5.0, 7.0]
+
+
+# ---------------------------------------------------------------------------
+# Portfolio analytics
+# ---------------------------------------------------------------------------
+
+
+class TestPortfolioAnalytics:
+    def test_correlation_matrix_shape(self):
+        from ferro_ta.analysis.portfolio import correlation_matrix
+
+        r = RNG.normal(0, 0.01, (100, 4))
+        corr = correlation_matrix(r)
+        assert corr.shape == (4, 4)
+
+    def test_correlation_matrix_diagonal_ones(self):
+        from ferro_ta.analysis.portfolio import correlation_matrix
+
+        r = RNG.normal(0, 0.01, (100, 3))
+        corr = correlation_matrix(r)
+        np.testing.assert_allclose(np.diag(corr), 1.0, atol=1e-10)
+
+    def test_correlation_matrix_symmetric(self):
+        from ferro_ta.analysis.portfolio import correlation_matrix
+
+        r = RNG.normal(0, 0.01, (80, 3))
+        corr = correlation_matrix(r)
+        np.testing.assert_allclose(corr, corr.T, atol=1e-12)
+
+    def test_portfolio_volatility_positive(self):
+        from ferro_ta.analysis.portfolio import portfolio_volatility
+
+        r = RNG.normal(0, 0.01, (100, 3))
+        vol = portfolio_volatility(r, weights=[1 / 3, 1 / 3, 1 / 3])
+        assert vol > 0
+
+    def test_portfolio_volatility_annualise(self):
+        from ferro_ta.analysis.portfolio import portfolio_volatility
+
+        r = RNG.normal(0, 0.01, (252, 1))
+        vol_raw = portfolio_volatility(r, weights=[1.0])
+        vol_ann = portfolio_volatility(r, weights=[1.0], annualise=252)
+        np.testing.assert_allclose(vol_ann, vol_raw * 252**0.5, rtol=1e-6)
+
+    def test_beta_scalar(self):
+        from ferro_ta.analysis.portfolio import beta
+
+        bench = RNG.normal(0, 0.01, 100)
+        asset = 1.5 * bench + RNG.normal(0, 0.001, 100)
+        b = beta(asset, bench)
+        assert abs(b - 1.5) < 0.05
+
+    def test_beta_rolling(self):
+        from ferro_ta.analysis.portfolio import beta
+
+        bench = RNG.normal(0, 0.01, 100)
+        asset = bench + RNG.normal(0, 0.001, 100)
+        rb = beta(asset, bench, window=20)
+        assert rb.shape == (100,)
+        assert np.isnan(rb[0])
+        assert not np.isnan(rb[-1])
+
+    def test_drawdown_series(self):
+        from ferro_ta.analysis.portfolio import drawdown
+
+        eq = np.array([100.0, 110.0, 105.0, 90.0, 95.0])
+        dd, max_dd = drawdown(eq)
+        assert dd.shape == (5,)
+        assert dd[0] == 0.0  # no drawdown at start
+        assert max_dd < 0
+
+    def test_drawdown_max_only(self):
+        from ferro_ta.analysis.portfolio import drawdown
+
+        eq = np.array([100.0, 110.0, 105.0, 90.0, 95.0])
+        max_dd = drawdown(eq, as_series=False)
+        assert isinstance(max_dd, float)
+        assert max_dd < 0
+
+
+# ---------------------------------------------------------------------------
+# Cross-asset analytics
+# ---------------------------------------------------------------------------
+
+
+class TestCrossAsset:
+    def test_relative_strength_shape(self):
+        from ferro_ta.analysis.cross_asset import relative_strength
+
+        ra = RNG.normal(0, 0.01, 50)
+        rb = RNG.normal(0, 0.01, 50)
+        rs = relative_strength(ra, rb)
+        assert rs.shape == (50,)
+
+    def test_spread_values(self):
+        from ferro_ta.analysis.cross_asset import spread
+
+        a = np.array([10.0, 11.0, 12.0])
+        b = np.array([9.0, 10.0, 11.0])
+        sp = spread(a, b)
+        np.testing.assert_allclose(sp, [1.0, 1.0, 1.0])
+
+    def test_spread_custom_hedge(self):
+        from ferro_ta.analysis.cross_asset import spread
+
+        a = np.array([10.0, 10.0])
+        b = np.array([5.0, 5.0])
+        sp = spread(a, b, hedge=2.0)
+        np.testing.assert_allclose(sp, [0.0, 0.0])
+
+    def test_ratio_basic(self):
+        from ferro_ta.analysis.cross_asset import ratio
+
+        a = np.array([10.0, 12.0, 15.0])
+        b = np.array([5.0, 4.0, 5.0])
+        r = ratio(a, b)
+        np.testing.assert_allclose(r, [2.0, 3.0, 3.0])
+
+    def test_ratio_zero_denominator(self):
+        from ferro_ta.analysis.cross_asset import ratio
+
+        a = np.array([1.0, 2.0])
+        b = np.array([0.0, 1.0])
+        r = ratio(a, b)
+        assert np.isnan(r[0])
+        assert r[1] == 2.0
+
+    def test_zscore_nan_warmup(self):
+        from ferro_ta.analysis.cross_asset import zscore
+
+        x = np.array([1.0, 2.0, 3.0, 2.0, 1.0])
+        z = zscore(x, window=3)
+        assert np.isnan(z[0]) and np.isnan(z[1])
+        assert not np.isnan(z[2])
+
+    def test_rolling_beta_warmup(self):
+        from ferro_ta.analysis.cross_asset import rolling_beta
+
+        b = RNG.normal(0, 1, 50)
+        a = 0.8 * b + RNG.normal(0, 0.1, 50)
+        rb = rolling_beta(a, b, window=20)
+        assert np.isnan(rb[18])
+        assert not np.isnan(rb[19])
+
+
+# ---------------------------------------------------------------------------
+# Feature matrix
+# ---------------------------------------------------------------------------
+
+
+class TestFeatureMatrix:
+    def test_basic_feature_matrix(self):
+        from ferro_ta.analysis.features import feature_matrix
+
+        o, h, l, c, v = _make_ohlcv(50)
+        ohlcv = {"close": c, "high": h, "low": l, "open": o, "volume": v}
+        fm = feature_matrix(ohlcv, [("SMA", {"timeperiod": 10})])
+        assert "SMA" in fm
+        arr = np.asarray(fm["SMA"] if isinstance(fm, dict) else fm["SMA"].values)
+        assert arr.shape == (50,)
+
+    def test_multiple_indicators_feature_matrix(self):
+        from ferro_ta.analysis.features import feature_matrix
+
+        o, h, l, c, v = _make_ohlcv(50)
+        ohlcv = {"close": c, "high": h, "low": l, "open": o, "volume": v}
+        fm = feature_matrix(
+            ohlcv,
+            [
+                ("SMA", {"timeperiod": 10}),
+                ("RSI", {"timeperiod": 14}),
+            ],
+        )
+        assert "SMA" in fm
+        assert "RSI" in fm
+
+    def test_nan_policy_drop(self):
+        pytest.importorskip("pandas")
+        import pandas as pd
+
+        from ferro_ta.analysis.features import feature_matrix
+
+        o, h, l, c, v = _make_ohlcv(50)
+        ohlcv = {"close": c, "high": h, "low": l, "open": o, "volume": v}
+        fm = feature_matrix(
+            ohlcv,
+            [("SMA", {"timeperiod": 10}), ("RSI", {"timeperiod": 14})],
+            nan_policy="drop",
+        )
+        assert isinstance(fm, pd.DataFrame)
+        assert not fm.isnull().any().any()
+
+    def test_feature_matrix_string_indicator(self):
+        from ferro_ta.analysis.features import feature_matrix
+
+        o, h, l, c, v = _make_ohlcv(50)
+        ohlcv = {"close": c, "high": h, "low": l, "open": o, "volume": v}
+        fm = feature_matrix(ohlcv, ["SMA"])
+        assert "SMA" in fm
+
+    def test_feature_matrix_mixed_fastpath_and_multi_output(self):
+        from ferro_ta.analysis.features import feature_matrix
+
+        o, h, l, c, v = _make_ohlcv(80)
+        ohlcv = {"close": c, "high": h, "low": l, "open": o, "volume": v}
+        fm = feature_matrix(
+            ohlcv,
+            [
+                ("SMA", {"timeperiod": 10}),
+                ("ATR", {"timeperiod": 14}),
+                ("BBANDS", {"timeperiod": 10}, 1),
+            ],
+        )
+        assert "SMA" in fm
+        assert "ATR" in fm
+        assert "BBANDS_1" in fm
+
+
+class TestComputeMany:
+    def test_close_indicators_match_public_api(self):
+        from ferro_ta import EMA, RSI, SMA
+        from ferro_ta.data.batch import compute_many
+
+        _, _, _, close, _ = _make_ohlcv(80)
+        results = compute_many(
+            [
+                ("SMA", {"timeperiod": 10}),
+                ("EMA", {"timeperiod": 12}),
+                ("RSI", {"timeperiod": 14}),
+            ],
+            close=close,
+        )
+
+        np.testing.assert_allclose(
+            results[0], SMA(close, timeperiod=10), equal_nan=True
+        )
+        np.testing.assert_allclose(
+            results[1], EMA(close, timeperiod=12), equal_nan=True
+        )
+        np.testing.assert_allclose(
+            results[2], RSI(close, timeperiod=14), equal_nan=True
+        )
+
+    def test_hlc_indicators_match_public_api(self):
+        from ferro_ta import ADX, ATR
+        from ferro_ta.data.batch import compute_many
+
+        _, high, low, close, _ = _make_ohlcv(80)
+        results = compute_many(
+            [
+                ("ATR", {"timeperiod": 14}),
+                ("ADX", {"timeperiod": 14}),
+            ],
+            close=close,
+            high=high,
+            low=low,
+        )
+
+        np.testing.assert_allclose(
+            results[0], ATR(high, low, close, timeperiod=14), equal_nan=True
+        )
+        np.testing.assert_allclose(
+            results[1], ADX(high, low, close, timeperiod=14), equal_nan=True
+        )
+
+    def test_unsupported_kwargs_fall_back_cleanly(self):
+        from ferro_ta import STDDEV
+        from ferro_ta.data.batch import compute_many
+
+        _, _, _, close, _ = _make_ohlcv(80)
+        result = compute_many(
+            [("STDDEV", {"timeperiod": 10, "nbdev": 2.0})], close=close
+        )
+        np.testing.assert_allclose(
+            result[0], STDDEV(close, timeperiod=10, nbdev=2.0), equal_nan=True
+        )
+
+
+# ---------------------------------------------------------------------------
+# Viz (smoke tests)
+# ---------------------------------------------------------------------------
+
+
+class TestViz:
+    def test_plot_matplotlib_no_show(self):
+        pytest.importorskip("matplotlib")
+        from ferro_ta import RSI
+        from ferro_ta.tools.viz import plot
+
+        o, h, l, c, v = _make_ohlcv(60)
+        ohlcv = {"close": c, "open": o, "high": h, "low": l, "volume": v}
+        rsi = RSI(c, timeperiod=14)
+        fig = plot(
+            ohlcv,
+            indicators={"RSI(14)": rsi},
+            backend="matplotlib",
+            show=False,
+        )
+        assert fig is not None
+        import matplotlib.pyplot as plt
+
+        plt.close("all")
+
+    def test_plot_unknown_backend_raises(self):
+        from ferro_ta.tools.viz import plot
+
+        o, h, l, c, v = _make_ohlcv(10)
+        with pytest.raises(ValueError, match="Unknown backend"):
+            plot({"close": c}, backend="bogus")
+
+    def test_plot_savefig(self, tmp_path):
+        pytest.importorskip("matplotlib")
+        from ferro_ta.tools.viz import plot
+
+        o, h, l, c, v = _make_ohlcv(30)
+        ohlcv = {"close": c, "open": o, "high": h, "low": l, "volume": v}
+        out = str(tmp_path / "chart.png")
+        plot(ohlcv, backend="matplotlib", savefig=out, show=False)
+        import os
+
+        assert os.path.exists(out)
+        import matplotlib.pyplot as plt
+
+        plt.close("all")
+
+
+# ---------------------------------------------------------------------------
+# Data adapters
+# ---------------------------------------------------------------------------
+
+
+class TestDataAdapters:
+    def test_in_memory_adapter(self):
+        from ferro_ta.data.adapters import InMemoryAdapter
+
+        o, h, l, c, v = _make_ohlcv(20)
+        adapter = InMemoryAdapter(
+            {"open": o, "high": h, "low": l, "close": c, "volume": v}
+        )
+        ohlcv = adapter.fetch()
+        assert "close" in ohlcv
+
+    def test_register_and_get_adapter(self):
+        from ferro_ta.data.adapters import DataAdapter, get_adapter, register_adapter
+
+        class MyAdapter(DataAdapter):
+            def fetch(self, **kwargs):
+                return {}
+
+        register_adapter("_test_my", MyAdapter)
+        cls = get_adapter("_test_my")
+        assert cls is MyAdapter
+
+    def test_get_unknown_adapter_raises(self):
+        from ferro_ta.data.adapters import get_adapter
+
+        with pytest.raises(KeyError):
+            get_adapter("_nonexistent_adapter_xyz")
+
+    def test_csv_adapter_requires_pandas(self, tmp_path):
+        """CsvAdapter can be instantiated without pandas; fetch raises ImportError."""
+        from ferro_ta.data.adapters import CsvAdapter
+
+        adapter = CsvAdapter(str(tmp_path / "fake.csv"))
+        assert adapter is not None
+
+    def test_csv_adapter_fetch(self, tmp_path):
+        pytest.importorskip("pandas")
+        import pandas as pd
+
+        from ferro_ta.data.adapters import CsvAdapter
+
+        o, h, l, c, v = _make_ohlcv(10)
+        csv_path = str(tmp_path / "ohlcv.csv")
+        df = pd.DataFrame({"open": o, "high": h, "low": l, "close": c, "volume": v})
+        df.to_csv(csv_path, index=False)
+        adapter = CsvAdapter(csv_path)
+        result = adapter.fetch()
+        assert "close" in result.columns
+        assert len(result) == 10
+
+    def test_builtin_adapters_registered(self):
+        from ferro_ta.data.adapters import CsvAdapter, InMemoryAdapter, get_adapter
+
+        assert get_adapter("csv") is CsvAdapter
+        assert get_adapter("memory") is InMemoryAdapter

ferro-ta-main/tests/unit/test_dataframe_integration.py

@@ -0,0 +1,224 @@
+"""Integration tests for pandas and polars DataFrame/Series support.
+
+Verifies that ferro_ta indicators transparently accept pandas Series and
+polars Series inputs, returning correctly shaped results with preserved
+index/name metadata.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from ferro_ta import BBANDS, EMA, MACD, RSI, SMA
+
+# ---------------------------------------------------------------------------
+# Pandas Series tests
+# ---------------------------------------------------------------------------
+
+
+class TestPandasSeries:
+    """Indicators accept pd.Series and return pd.Series with index."""
+
+    def test_sma_returns_series(self, ohlcv_500):
+        s = pd.Series(ohlcv_500["close"])
+        result = SMA(s, timeperiod=14)
+        assert isinstance(result, pd.Series)
+        assert len(result) == len(s)
+
+    def test_ema_returns_series(self, ohlcv_500):
+        s = pd.Series(ohlcv_500["close"])
+        result = EMA(s, timeperiod=14)
+        assert isinstance(result, pd.Series)
+        assert len(result) == len(s)
+
+    def test_rsi_returns_series(self, ohlcv_500):
+        s = pd.Series(ohlcv_500["close"])
+        result = RSI(s, timeperiod=14)
+        assert isinstance(result, pd.Series)
+        assert len(result) == len(s)
+
+    def test_bbands_returns_tuple_of_series(self, ohlcv_500):
+        s = pd.Series(ohlcv_500["close"])
+        upper, middle, lower = BBANDS(s, timeperiod=5)
+        for band in (upper, middle, lower):
+            assert isinstance(band, pd.Series)
+            assert len(band) == len(s)
+
+    def test_macd_returns_tuple_of_series(self, ohlcv_500):
+        s = pd.Series(ohlcv_500["close"])
+        macd, signal, hist = MACD(s)
+        for arr in (macd, signal, hist):
+            assert isinstance(arr, pd.Series)
+            assert len(arr) == len(s)
+
+    def test_index_preserved(self, ohlcv_500):
+        """Resulting Series should carry the same index as the input."""
+        idx = pd.date_range("2020-01-01", periods=len(ohlcv_500["close"]), freq="D")
+        s = pd.Series(ohlcv_500["close"], index=idx)
+        result = SMA(s, timeperiod=14)
+        assert isinstance(result, pd.Series)
+        pd.testing.assert_index_equal(result.index, idx)
+
+    def test_named_series(self, ohlcv_500):
+        """Named Series should still work (name is not necessarily preserved,
+        but the call should not error)."""
+        s = pd.Series(ohlcv_500["close"], name="close_price")
+        result = EMA(s, timeperiod=10)
+        assert isinstance(result, pd.Series)
+        assert len(result) == len(s)
+
+    def test_series_with_nan_values(self):
+        """NaN values in the input should not crash the indicator."""
+        data = np.array([1.0, 2.0, np.nan, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])
+        s = pd.Series(data)
+        result = SMA(s, timeperiod=3)
+        assert isinstance(result, pd.Series)
+        assert len(result) == len(s)
+
+    def test_bbands_index_preserved(self, ohlcv_500):
+        idx = pd.date_range("2020-01-01", periods=len(ohlcv_500["close"]), freq="D")
+        s = pd.Series(ohlcv_500["close"], index=idx)
+        upper, middle, lower = BBANDS(s, timeperiod=5)
+        for band in (upper, middle, lower):
+            pd.testing.assert_index_equal(band.index, idx)
+
+    def test_macd_index_preserved(self, ohlcv_500):
+        idx = pd.date_range("2020-01-01", periods=len(ohlcv_500["close"]), freq="D")
+        s = pd.Series(ohlcv_500["close"], index=idx)
+        macd, signal, hist = MACD(s)
+        for arr in (macd, signal, hist):
+            pd.testing.assert_index_equal(arr.index, idx)
+
+
+# ---------------------------------------------------------------------------
+# Polars Series tests
+# ---------------------------------------------------------------------------
+
+
+class TestPolarsSeries:
+    """Indicators accept polars.Series and return polars.Series."""
+
+    @pytest.fixture(autouse=True)
+    def _require_polars(self):
+        self.pl = pytest.importorskip("polars")
+
+    def test_sma_returns_polars_series(self, ohlcv_500):
+        s = self.pl.Series("close", ohlcv_500["close"])
+        result = SMA(s, timeperiod=14)
+        assert isinstance(result, self.pl.Series)
+        assert len(result) == len(s)
+
+    def test_ema_returns_polars_series(self, ohlcv_500):
+        s = self.pl.Series("close", ohlcv_500["close"])
+        result = EMA(s, timeperiod=14)
+        assert isinstance(result, self.pl.Series)
+        assert len(result) == len(s)
+
+    def test_rsi_returns_polars_series(self, ohlcv_500):
+        s = self.pl.Series("close", ohlcv_500["close"])
+        result = RSI(s, timeperiod=14)
+        assert isinstance(result, self.pl.Series)
+        assert len(result) == len(s)
+
+    def test_bbands_returns_tuple_of_polars_series(self, ohlcv_500):
+        s = self.pl.Series("close", ohlcv_500["close"])
+        upper, middle, lower = BBANDS(s, timeperiod=5)
+        for band in (upper, middle, lower):
+            assert isinstance(band, self.pl.Series)
+            assert len(band) == len(s)
+
+    def test_macd_returns_tuple_of_polars_series(self, ohlcv_500):
+        s = self.pl.Series("close", ohlcv_500["close"])
+        macd, signal, hist = MACD(s)
+        for arr in (macd, signal, hist):
+            assert isinstance(arr, self.pl.Series)
+            assert len(arr) == len(s)
+
+    def test_series_name_preserved(self, ohlcv_500):
+        """The polars Series name from the first input should be carried through."""
+        s = self.pl.Series("my_close", ohlcv_500["close"])
+        result = SMA(s, timeperiod=14)
+        assert isinstance(result, self.pl.Series)
+        assert result.name == "my_close"
+
+
+# ---------------------------------------------------------------------------
+# DataFrame workflow tests
+# ---------------------------------------------------------------------------
+
+
+class TestDataFrameWorkflow:
+    """End-to-end workflow: build a DataFrame, compute indicators, add columns."""
+
+    def test_pandas_dataframe_workflow(self, ohlcv_500):
+        df = pd.DataFrame(ohlcv_500)
+
+        # Compute indicators from DataFrame columns
+        df["sma_14"] = SMA(df["close"], timeperiod=14)
+        df["ema_14"] = EMA(df["close"], timeperiod=14)
+        df["rsi_14"] = RSI(df["close"], timeperiod=14)
+
+        upper, middle, lower = BBANDS(df["close"], timeperiod=5)
+        df["bb_upper"] = upper
+        df["bb_middle"] = middle
+        df["bb_lower"] = lower
+
+        macd, signal, hist = MACD(df["close"])
+        df["macd"] = macd
+        df["macd_signal"] = signal
+        df["macd_hist"] = hist
+
+        # All new columns should exist and have correct length
+        new_cols = [
+            "sma_14",
+            "ema_14",
+            "rsi_14",
+            "bb_upper",
+            "bb_middle",
+            "bb_lower",
+            "macd",
+            "macd_signal",
+            "macd_hist",
+        ]
+        for col in new_cols:
+            assert col in df.columns
+            assert len(df[col]) == 500
+
+        # SMA leading values should be NaN
+        assert np.isnan(df["sma_14"].iloc[0])
+        # Non-NaN values should exist after warmup
+        assert not np.isnan(df["sma_14"].iloc[-1])
+
+    def test_pandas_dataframe_index_consistency(self, ohlcv_500):
+        """Indicator columns should align with the original DataFrame index."""
+        idx = pd.date_range("2020-01-01", periods=500, freq="D")
+        df = pd.DataFrame(ohlcv_500, index=idx)
+
+        df["sma_14"] = SMA(df["close"], timeperiod=14)
+        pd.testing.assert_index_equal(df["sma_14"].dropna().index, idx[13:])
+
+    def test_polars_dataframe_workflow(self, ohlcv_500):
+        pl = pytest.importorskip("polars")
+        df = pl.DataFrame(ohlcv_500)
+
+        sma_result = SMA(df["close"], timeperiod=14)
+        ema_result = EMA(df["close"], timeperiod=14)
+        rsi_result = RSI(df["close"], timeperiod=14)
+
+        # Results are polars Series of correct length
+        for result in (sma_result, ema_result, rsi_result):
+            assert isinstance(result, pl.Series)
+            assert len(result) == 500
+
+        # Can add back to a polars DataFrame via with_columns
+        df2 = df.with_columns(
+            sma_result.alias("sma_14"),
+            ema_result.alias("ema_14"),
+            rsi_result.alias("rsi_14"),
+        )
+        assert "sma_14" in df2.columns
+        assert "ema_14" in df2.columns
+        assert "rsi_14" in df2.columns
+        assert df2.shape[0] == 500

ferro-ta-main/tests/unit/test_derivatives.py

@@ -0,0 +1,651 @@
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+
+class TestOptionsAnalytics:
+    def test_black_scholes_price_scalar(self):
+        from ferro_ta.analysis.options import black_scholes_price
+
+        price = black_scholes_price(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.2,
+            option_type="call",
+        )
+        assert price == pytest.approx(10.4506, rel=1e-4)
+
+    def test_black_76_price_vectorized(self):
+        from ferro_ta.analysis.options import black_76_price
+
+        price = black_76_price(
+            np.array([100.0, 105.0]),
+            np.array([100.0, 100.0]),
+            0.03,
+            1.0,
+            np.array([0.2, 0.25]),
+            option_type="call",
+        )
+        assert isinstance(price, np.ndarray)
+        assert price.shape == (2,)
+        assert np.all(price > 0.0)
+
+    def test_greeks_and_iv_recovery(self):
+        from ferro_ta.analysis.options import greeks, implied_volatility, option_price
+
+        price = option_price(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.2,
+            option_type="call",
+            model="bsm",
+        )
+        iv = implied_volatility(
+            price,
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            option_type="call",
+            model="bsm",
+        )
+        result = greeks(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.2,
+            option_type="call",
+            model="bsm",
+        )
+        assert iv == pytest.approx(0.2, rel=1e-6)
+        assert result.delta == pytest.approx(0.6368, rel=1e-3)
+        assert result.gamma > 0.0
+        assert result.vega > 0.0
+
+    def test_smile_and_chain_helpers(self):
+        from ferro_ta.analysis.options import (
+            label_moneyness,
+            select_strike,
+            smile_metrics,
+            term_structure_slope,
+        )
+
+        strikes = np.array([80.0, 90.0, 100.0, 110.0, 120.0])
+        vols = np.array([0.30, 0.25, 0.20, 0.22, 0.27])
+
+        metrics = smile_metrics(strikes, vols, 100.0, 0.5)
+        labels = label_moneyness(strikes, 100.0, option_type="call")
+
+        assert metrics.atm_iv == pytest.approx(0.20, rel=1e-6)
+        assert metrics.skew_slope < 0.0
+        assert labels.tolist() == ["ITM", "ITM", "ATM", "OTM", "OTM"]
+        assert select_strike(strikes, 101.0, selector="ATM") == 100.0
+        assert (
+            select_strike(strikes, 101.0, option_type="call", selector="OTM2") == 120.0
+        )
+        assert select_strike(
+            strikes,
+            100.0,
+            selector="DELTA0.25",
+            option_type="call",
+            volatilities=vols,
+            time_to_expiry=0.5,
+        ) in set(strikes.tolist())
+        assert term_structure_slope([0.1, 0.5, 1.0], [0.18, 0.20, 0.22]) > 0.0
+
+
+class TestFuturesAnalytics:
+    def test_basis_and_curve_helpers(self):
+        from ferro_ta.analysis.futures import (
+            annualized_basis,
+            basis,
+            calendar_spreads,
+            carry_spread,
+            curve_summary,
+            implied_carry_rate,
+            synthetic_forward,
+        )
+
+        assert basis(100.0, 103.0) == pytest.approx(3.0)
+        assert annualized_basis(100.0, 103.0, 0.25) > 0.0
+        assert implied_carry_rate(100.0, 103.0, 0.25) > 0.0
+        assert carry_spread(100.0, 103.0, 0.02, 0.25) > -1.0
+        assert synthetic_forward(8.0, 5.0, 100.0, 0.02, 0.5) > 100.0
+        assert np.allclose(calendar_spreads([100.0, 101.0, 103.0]), [1.0, 2.0])
+
+        summary = curve_summary(100.0, [0.1, 0.5, 1.0], [101.0, 102.0, 104.0])
+        assert summary.is_contango is True
+        assert summary.slope > 0.0
+
+    def test_roll_helpers(self):
+        from ferro_ta.analysis.futures import (
+            back_adjusted_continuous_contract,
+            ratio_adjusted_continuous_contract,
+            roll_yield,
+            weighted_continuous_contract,
+        )
+
+        front = np.array([100.0, 101.0, 102.0, 103.0])
+        nxt = np.array([101.0, 102.0, 103.0, 104.0])
+        weights = np.array([0.0, 0.25, 0.75, 1.0])
+
+        weighted = weighted_continuous_contract(front, nxt, weights)
+        back_adjusted = back_adjusted_continuous_contract(front, nxt, weights)
+        ratio_adjusted = ratio_adjusted_continuous_contract(front, nxt, weights)
+
+        assert weighted.shape == front.shape
+        assert back_adjusted.shape == front.shape
+        assert ratio_adjusted.shape == front.shape
+        assert roll_yield(100.0, 102.0, 30.0 / 365.0) > 0.0
+
+
+class TestStrategyAndPayoff:
+    def test_strategy_schema_and_preset(self):
+        from ferro_ta.analysis.options_strategy import (
+            DerivativesStrategy,
+            ExpirySelector,
+            ExpirySelectorKind,
+            LegPreset,
+            StrategyLeg,
+            StrikeSelector,
+            StrikeSelectorKind,
+            build_strategy_preset,
+        )
+
+        preset = build_strategy_preset(
+            LegPreset.STRADDLE,
+            name="ATM Straddle",
+            underlying="NIFTY",
+            expiry_selector=ExpirySelector(ExpirySelectorKind.CURRENT_WEEK),
+        )
+        custom = DerivativesStrategy(
+            name="Custom Single",
+            legs=(
+                StrategyLeg(
+                    "NIFTY",
+                    ExpirySelector(ExpirySelectorKind.CURRENT_WEEK),
+                    StrikeSelector(
+                        StrikeSelectorKind.EXPLICIT, explicit_strike=22000.0
+                    ),
+                    "call",
+                ),
+            ),
+        )
+
+        assert len(preset.legs) == 2
+        assert custom.to_dict()["name"] == "Custom Single"
+
+    def test_payoff_and_aggregate_greeks(self):
+        from ferro_ta.analysis.derivatives_payoff import (
+            PayoffLeg,
+            aggregate_greeks,
+            strategy_payoff,
+        )
+
+        spot_grid = np.array([90.0, 100.0, 110.0])
+        legs = [
+            PayoffLeg(
+                instrument="option",
+                side="long",
+                option_type="call",
+                strike=100.0,
+                premium=5.0,
+                volatility=0.2,
+                time_to_expiry=0.5,
+            ),
+            PayoffLeg(
+                instrument="option",
+                side="short",
+                option_type="call",
+                strike=110.0,
+                premium=2.0,
+                volatility=0.22,
+                time_to_expiry=0.5,
+            ),
+            PayoffLeg(instrument="future", side="long", entry_price=100.0),
+        ]
+
+        payoff = strategy_payoff(spot_grid, legs=legs)
+        greeks = aggregate_greeks(100.0, legs=legs)
+
+        assert payoff.shape == spot_grid.shape
+        assert payoff[1] == pytest.approx(-3.0)
+        assert greeks.delta > 0.0
+        assert greeks.gamma > 0.0
+
+
+class TestStockInstrument:
+    def test_stock_leg_payoff_linear(self):
+        from ferro_ta.analysis.derivatives_payoff import stock_leg_payoff
+
+        spot_grid = np.array([90.0, 100.0, 110.0])
+        payoff = stock_leg_payoff(spot_grid, entry_price=100.0, side="long")
+        assert payoff == pytest.approx([-10.0, 0.0, 10.0])
+
+    def test_stock_leg_short_side(self):
+        from ferro_ta.analysis.derivatives_payoff import stock_leg_payoff
+
+        spot_grid = np.array([90.0, 100.0, 110.0])
+        payoff = stock_leg_payoff(spot_grid, entry_price=100.0, side="short")
+        assert payoff == pytest.approx([10.0, 0.0, -10.0])
+
+    def test_strategy_payoff_with_stock_leg(self):
+        from ferro_ta.analysis.derivatives_payoff import PayoffLeg, strategy_payoff
+
+        # Covered call: long stock + short call
+        spot_grid = np.array([90.0, 100.0, 110.0, 120.0])
+        legs = [
+            PayoffLeg(instrument="stock", side="long", entry_price=100.0),
+            PayoffLeg(
+                instrument="option",
+                side="short",
+                option_type="call",
+                strike=110.0,
+                premium=3.0,
+            ),
+        ]
+        payoff = strategy_payoff(spot_grid, legs=legs)
+        assert payoff.shape == spot_grid.shape
+        # At 90: stock P&L = -10, short call = +3 (OTM) → total = -7
+        assert payoff[0] == pytest.approx(-7.0)
+        # At 110: stock P&L = +10, short call = +3 (ATM, intrinsic=0) → total = +13
+        assert payoff[2] == pytest.approx(13.0)
+
+    def test_strategy_leg_accepts_stock_instrument(self):
+        from ferro_ta.analysis.options_strategy import StrategyLeg
+
+        leg = StrategyLeg(
+            underlying="NIFTY",
+            expiry_selector=None,
+            strike_selector=None,
+            option_type=None,
+            instrument="stock",
+            side="long",
+        )
+        assert leg.instrument == "stock"
+
+
+class TestExtendedGreeks:
+    def test_extended_greeks_returns_five_values(self):
+        from ferro_ta.analysis.options import ExtendedGreeks, extended_greeks
+
+        eg = extended_greeks(100.0, 100.0, 0.05, 1.0, 0.2, option_type="call")
+        assert isinstance(eg, ExtendedGreeks)
+        assert eg.vanna is not None
+        assert eg.volga is not None
+        assert eg.charm is not None
+        assert eg.speed is not None
+        assert eg.color is not None
+
+    def test_vanna_sign_otm_call(self):
+        # OTM call vanna > 0 (delta increases as vol rises)
+        from ferro_ta.analysis.options import extended_greeks
+
+        eg = extended_greeks(100.0, 110.0, 0.05, 1.0, 0.2, option_type="call")
+        assert eg.vanna > 0.0
+
+    def test_extended_greeks_finite_for_valid_inputs(self):
+        from ferro_ta.analysis.options import extended_greeks
+
+        eg = extended_greeks(100.0, 100.0, 0.05, 1.0, 0.25, option_type="put")
+        assert np.isfinite(eg.vanna)
+        assert np.isfinite(eg.volga)
+        assert np.isfinite(eg.charm)
+        assert np.isfinite(eg.speed)
+        assert np.isfinite(eg.color)
+
+    def test_volga_positive_atm(self):
+        # Volga is always non-negative for standard BSM inputs
+        from ferro_ta.analysis.options import extended_greeks
+
+        eg = extended_greeks(100.0, 100.0, 0.05, 1.0, 0.2, option_type="call")
+        assert eg.volga >= 0.0
+
+
+class TestDigitalOptions:
+    def test_cash_or_nothing_call_atm(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        # ATM cash-or-nothing call ≈ e^{-rT} * N(d2) ≈ 0.532
+        price = digital_option_price(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.2,
+            option_type="call",
+            digital_type="cash_or_nothing",
+        )
+        assert 0.0 < price < 1.0
+        assert price == pytest.approx(0.532, rel=0.02)
+
+    def test_asset_or_nothing_call_atm(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        price = digital_option_price(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.2,
+            option_type="call",
+            digital_type="asset_or_nothing",
+        )
+        # asset-or-nothing call ≈ S * N(d1) < S
+        assert 0.0 < price < 100.0
+
+    def test_put_call_parity_cash_or_nothing(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        call = digital_option_price(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.25,
+            option_type="call",
+            digital_type="cash_or_nothing",
+        )
+        put = digital_option_price(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.25,
+            option_type="put",
+            digital_type="cash_or_nothing",
+        )
+        discount = np.exp(-0.05)
+        assert call + put == pytest.approx(discount, rel=1e-6)
+
+    def test_digital_greeks_finite(self):
+        from ferro_ta.analysis.options import digital_option_greeks
+
+        g = digital_option_greeks(
+            100.0,
+            100.0,
+            0.05,
+            1.0,
+            0.2,
+            option_type="call",
+            digital_type="cash_or_nothing",
+        )
+        assert np.isfinite(g.delta)
+        assert np.isfinite(g.gamma)
+        assert np.isfinite(g.vega)
+
+    def test_digital_invalid_returns_nan(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        price = digital_option_price(
+            -1.0,
+            100.0,
+            0.05,
+            1.0,
+            0.2,
+            option_type="call",
+            digital_type="cash_or_nothing",
+        )
+        assert np.isnan(price)
+
+
+class TestAmericanOptions:
+    def test_american_price_gte_european(self):
+        from ferro_ta.analysis.options import american_option_price, option_price
+
+        spot, strike, rate, tte, vol = 100.0, 100.0, 0.05, 1.0, 0.2
+        american = american_option_price(
+            spot, strike, rate, tte, vol, option_type="call"
+        )
+        european = option_price(spot, strike, rate, tte, vol, option_type="call")
+        assert american >= european - 1e-8
+
+    def test_early_exercise_premium_nonnegative(self):
+        from ferro_ta.analysis.options import early_exercise_premium
+
+        premium = early_exercise_premium(
+            100.0, 100.0, 0.05, 1.0, 0.2, option_type="put"
+        )
+        assert premium >= 0.0
+
+    def test_american_put_early_exercise_positive(self):
+        # Deep ITM put with high rate should have meaningful early exercise premium
+        from ferro_ta.analysis.options import early_exercise_premium
+
+        premium = early_exercise_premium(80.0, 100.0, 0.1, 0.5, 0.25, option_type="put")
+        assert premium > 0.0
+
+    def test_american_call_no_dividends_no_premium(self):
+        # With zero carry (no dividends), American call = European call
+        from ferro_ta.analysis.options import early_exercise_premium
+
+        premium = early_exercise_premium(
+            100.0, 100.0, 0.05, 1.0, 0.2, option_type="call", carry=0.0
+        )
+        assert premium == pytest.approx(0.0, abs=1e-4)
+
+
+class TestVolEstimators:
+    @pytest.fixture
+    def sample_ohlc(self):
+        rng = np.random.default_rng(42)
+        n = 100
+        log_ret = rng.normal(0.0, 0.01, n)
+        close = 100.0 * np.cumprod(np.exp(log_ret))
+        high = close * np.exp(np.abs(rng.normal(0.0, 0.005, n)))
+        low = close * np.exp(-np.abs(rng.normal(0.0, 0.005, n)))
+        open_ = np.roll(close, 1)
+        open_[0] = close[0]
+        return open_, high, low, close
+
+    def test_close_to_close_vol_length(self, sample_ohlc):
+        from ferro_ta.analysis.options import close_to_close_vol
+
+        _, _, _, close = sample_ohlc
+        out = close_to_close_vol(close, window=20)
+        assert len(out) == len(close)
+
+    def test_close_to_close_vol_warmup_nan(self, sample_ohlc):
+        from ferro_ta.analysis.options import close_to_close_vol
+
+        _, _, _, close = sample_ohlc
+        out = close_to_close_vol(close, window=20)
+        # First `window` values are NaN; index `window` is the first valid value
+        assert all(np.isnan(out[:20]))
+        assert np.isfinite(out[20])
+
+    def test_parkinson_vol_finite_and_positive(self, sample_ohlc):
+        from ferro_ta.analysis.options import parkinson_vol
+
+        _, high, low, _ = sample_ohlc
+        out = parkinson_vol(high, low, window=20)
+        finite = out[~np.isnan(out)]
+        assert len(finite) > 0
+        assert np.all(finite > 0.0)
+
+    def test_garman_klass_vol(self, sample_ohlc):
+        from ferro_ta.analysis.options import garman_klass_vol
+
+        open_, high, low, close = sample_ohlc
+        out = garman_klass_vol(open_, high, low, close, window=20)
+        finite = out[~np.isnan(out)]
+        assert len(finite) > 0
+        assert np.all(finite > 0.0)
+
+    def test_rogers_satchell_vol(self, sample_ohlc):
+        from ferro_ta.analysis.options import rogers_satchell_vol
+
+        open_, high, low, close = sample_ohlc
+        out = rogers_satchell_vol(open_, high, low, close, window=20)
+        finite = out[~np.isnan(out)]
+        assert len(finite) > 0
+
+    def test_yang_zhang_vol(self, sample_ohlc):
+        from ferro_ta.analysis.options import yang_zhang_vol
+
+        open_, high, low, close = sample_ohlc
+        out = yang_zhang_vol(open_, high, low, close, window=20)
+        finite = out[~np.isnan(out)]
+        assert len(finite) > 0
+        assert np.all(finite > 0.0)
+
+    def test_yang_zhang_lower_variance_than_close_to_close(self, sample_ohlc):
+        # YZ is more efficient than close-to-close
+        from ferro_ta.analysis.options import close_to_close_vol, yang_zhang_vol
+
+        open_, high, low, close = sample_ohlc
+        c2c = close_to_close_vol(close, window=20)
+        yz = yang_zhang_vol(open_, high, low, close, window=20)
+        valid = ~np.isnan(c2c) & ~np.isnan(yz)
+        # YZ variance < C2C variance (efficiency test)
+        assert np.var(yz[valid]) <= np.var(c2c[valid]) * 2.0  # lenient bound
+
+
+class TestVolCone:
+    def test_vol_cone_shape(self):
+        from ferro_ta.analysis.options import VolCone, vol_cone
+
+        rng = np.random.default_rng(0)
+        close = 100.0 * np.cumprod(np.exp(rng.normal(0.0, 0.01, 300)))
+        cone = vol_cone(close, windows=(21, 42, 63))
+        assert isinstance(cone, VolCone)
+        assert len(cone.windows) == 3
+        assert len(cone.min) == 3
+
+    def test_vol_cone_monotonic_percentiles(self):
+        from ferro_ta.analysis.options import vol_cone
+
+        rng = np.random.default_rng(1)
+        close = 100.0 * np.cumprod(np.exp(rng.normal(0.0, 0.01, 500)))
+        cone = vol_cone(close, windows=(21, 42, 63, 126, 252))
+        for i in range(len(cone.windows)):
+            assert (
+                cone.min[i]
+                <= cone.p25[i]
+                <= cone.median[i]
+                <= cone.p75[i]
+                <= cone.max[i]
+            )
+
+    def test_vol_cone_positive_values(self):
+        from ferro_ta.analysis.options import vol_cone
+
+        rng = np.random.default_rng(2)
+        close = 100.0 * np.cumprod(np.exp(rng.normal(0.0, 0.01, 400)))
+        cone = vol_cone(close)
+        assert np.all(cone.min > 0.0)
+
+
+class TestStrategyAnalytics:
+    def test_put_call_parity_deviation_zero(self):
+        from ferro_ta.analysis.options import option_price, put_call_parity_deviation
+
+        s, k, r, tte, vol = 100.0, 100.0, 0.05, 1.0, 0.2
+        call = option_price(s, k, r, tte, vol, option_type="call")
+        put = option_price(s, k, r, tte, vol, option_type="put")
+        dev = put_call_parity_deviation(call, put, s, k, r, tte)
+        assert dev == pytest.approx(0.0, abs=1e-6)
+
+    def test_put_call_parity_deviation_nonzero_for_stale_quote(self):
+        from ferro_ta.analysis.options import put_call_parity_deviation
+
+        dev = put_call_parity_deviation(15.0, 5.0, 100.0, 100.0, 0.05, 1.0)
+        assert abs(dev) > 0.01
+
+    def test_expected_move_positive(self):
+        from ferro_ta.analysis.options import expected_move
+
+        lower, upper = expected_move(100.0, 0.2, 30.0)
+        assert upper > 0.0
+        assert lower < 0.0
+
+    def test_expected_move_log_normal_asymmetry(self):
+        # Log-normal expected move: upper > |lower| (right-skew)
+        from ferro_ta.analysis.options import expected_move
+
+        lower, upper = expected_move(100.0, 0.2, 30.0)
+        # Both magnitudes are similar (within 10%) but upper > |lower|
+        assert upper > abs(lower) * 0.95
+        assert upper < abs(lower) * 2.0
+
+    def test_strategy_value_near_expiry_approx_payoff(self):
+        from ferro_ta.analysis.derivatives_payoff import (
+            PayoffLeg,
+            strategy_payoff,
+            strategy_value,
+        )
+
+        # Near expiry, BSM value ≈ intrinsic payoff
+        spot_grid = np.array([90.0, 100.0, 110.0])
+        legs = [
+            PayoffLeg(
+                instrument="option",
+                side="long",
+                option_type="call",
+                strike=100.0,
+                premium=0.0,
+                volatility=0.2,
+                time_to_expiry=0.001,
+            )
+        ]
+        val = strategy_value(spot_grid, legs=legs, time_to_expiry=0.001, volatility=0.2)
+        payoff = strategy_payoff(spot_grid, legs=legs)
+        # Near expiry, value ≈ payoff (within a few cents)
+        assert np.allclose(val, payoff, atol=0.5)
+
+    def test_strategy_value_shape(self):
+        from ferro_ta.analysis.derivatives_payoff import PayoffLeg, strategy_value
+
+        spot_grid = np.linspace(80.0, 120.0, 20)
+        legs = [
+            PayoffLeg(
+                instrument="option",
+                side="long",
+                option_type="call",
+                strike=100.0,
+                premium=5.0,
+                volatility=0.2,
+                time_to_expiry=0.5,
+            )
+        ]
+        val = strategy_value(spot_grid, legs=legs, time_to_expiry=0.5, volatility=0.2)
+        assert val.shape == spot_grid.shape
+
+
+class TestDerivativesBenchmarking:
+    def test_derivatives_benchmark_smoke(self, tmp_path):
+        root = Path(__file__).resolve().parents[2]
+        script = root / "benchmarks" / "bench_derivatives_compare.py"
+        output_path = tmp_path / "derivatives_benchmark.json"
+
+        completed = subprocess.run(
+            [
+                sys.executable,
+                str(script),
+                "--sizes",
+                "32",
+                "--accuracy-size",
+                "16",
+                "--json",
+                str(output_path),
+            ],
+            cwd=root,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+
+        assert completed.returncode == 0, completed.stdout + completed.stderr
+        assert output_path.is_file()
+        payload = output_path.read_text(encoding="utf-8")
+        assert '"accuracy"' in payload
+        assert '"speed"' in payload
+        assert '"provider": "ferro_ta"' in payload

ferro-ta-main/tests/unit/test_derivatives_accuracy.py

@@ -0,0 +1,608 @@
+"""
+Accuracy/correctness tests for ferro-ta derivatives analytics.
+
+Each test class validates the ferro-ta implementation against reference
+formulas implemented using scipy and numpy.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+# ---------------------------------------------------------------------------
+# Reference formulas (pure numpy / scipy)
+# ---------------------------------------------------------------------------
+
+
+def _norm_cdf(x):
+    """Standard normal CDF via scipy."""
+    from scipy.stats import norm as _norm
+
+    return _norm.cdf(x)
+
+
+def _norm_pdf(x):
+    from scipy.stats import norm as _norm
+
+    return _norm.pdf(x)
+
+
+def bsm_call(S, K, r, q, T, sigma):  # noqa: N803
+    """Reference BSM call price."""
+    d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    d2 = d1 - sigma * np.sqrt(T)
+    return S * np.exp(-q * T) * _norm_cdf(d1) - K * np.exp(-r * T) * _norm_cdf(d2)
+
+
+def bsm_put(S, K, r, q, T, sigma):  # noqa: N803
+    d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    d2 = d1 - sigma * np.sqrt(T)
+    return K * np.exp(-r * T) * _norm_cdf(-d2) - S * np.exp(-q * T) * _norm_cdf(-d1)
+
+
+def bsm_delta_call(S, K, r, q, T, sigma):  # noqa: N803
+    d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    return np.exp(-q * T) * _norm_cdf(d1)
+
+
+def digital_cash_call(S, K, r, q, T, sigma):  # noqa: N803
+    d2 = (np.log(S / K) + (r - q - 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    return np.exp(-r * T) * _norm_cdf(d2)
+
+
+def digital_asset_call(S, K, r, q, T, sigma):  # noqa: N803
+    d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    return S * np.exp(-q * T) * _norm_cdf(d1)
+
+
+def digital_cash_put(S, K, r, q, T, sigma):  # noqa: N803
+    d2 = (np.log(S / K) + (r - q - 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    return np.exp(-r * T) * _norm_cdf(-d2)
+
+
+def digital_asset_put(S, K, r, q, T, sigma):  # noqa: N803
+    d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    return S * np.exp(-q * T) * _norm_cdf(-d1)
+
+
+def vanna_num(S, K, r, q, T, sigma, eps=1e-4):  # noqa: N803
+    """∂Δ/∂σ via central differences."""
+    delta_up = bsm_delta_call(S, K, r, q, T, sigma + eps)
+    delta_dn = bsm_delta_call(S, K, r, q, T, sigma - eps)
+    return (delta_up - delta_dn) / (2 * eps)
+
+
+def vega_bsm(S, K, r, q, T, sigma):  # noqa: N803
+    d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    return S * np.exp(-q * T) * _norm_pdf(d1) * np.sqrt(T)
+
+
+def volga_num(S, K, r, q, T, sigma, eps=1e-4):  # noqa: N803
+    """∂²V/∂σ² via central differences."""
+    v_up = vega_bsm(S, K, r, q, T, sigma + eps)
+    v_dn = vega_bsm(S, K, r, q, T, sigma - eps)
+    return (v_up - v_dn) / (2 * eps)
+
+
+def ctc_vol_reference(close, window, trading_days=252.0):
+    """Close-to-close vol: rolling std of log returns × sqrt(trading_days)."""
+    log_ret = np.log(close[1:] / close[:-1])
+    n = len(close)
+    out = np.full(n, np.nan)
+    for i in range(window, n):
+        returns_window = log_ret[i - window : i]
+        out[i] = np.sqrt(np.sum(returns_window**2) / window * trading_days)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+# Six parameter sets: ATM, 10% OTM, 10% ITM, low vol, high vol, non-zero carry
+_DIGITAL_CASES = [
+    # (S, K, r, q, T, sigma, label)
+    (100.0, 100.0, 0.05, 0.00, 1.0, 0.20, "ATM"),
+    (100.0, 110.0, 0.05, 0.00, 1.0, 0.20, "10% OTM"),
+    (100.0, 90.0, 0.05, 0.00, 1.0, 0.20, "10% ITM"),
+    (100.0, 100.0, 0.05, 0.00, 1.0, 0.05, "low vol"),
+    (100.0, 100.0, 0.05, 0.00, 1.0, 0.50, "high vol"),
+    (100.0, 100.0, 0.05, 0.03, 1.0, 0.20, "non-zero carry"),
+]
+
+
+class TestDigitalOptionsAccuracy:
+    @pytest.fixture(autouse=True)
+    def require_scipy(self):
+        pytest.importorskip("scipy")
+
+    def test_cash_or_nothing_call_vs_reference(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        for S, K, r, q, T, sigma, label in _DIGITAL_CASES:
+            expected = digital_cash_call(S, K, r, q, T, sigma)
+            actual = digital_option_price(
+                S,
+                K,
+                r,
+                T,
+                sigma,
+                option_type="call",
+                digital_type="cash_or_nothing",
+                carry=q,
+            )
+            assert actual == pytest.approx(expected, abs=1e-6), (
+                f"cash_or_nothing call mismatch for case '{label}': "
+                f"got {actual}, expected {expected}"
+            )
+
+    def test_cash_or_nothing_put_vs_reference(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        for S, K, r, q, T, sigma, label in _DIGITAL_CASES:
+            expected = digital_cash_put(S, K, r, q, T, sigma)
+            actual = digital_option_price(
+                S,
+                K,
+                r,
+                T,
+                sigma,
+                option_type="put",
+                digital_type="cash_or_nothing",
+                carry=q,
+            )
+            assert actual == pytest.approx(expected, abs=1e-6), (
+                f"cash_or_nothing put mismatch for case '{label}': "
+                f"got {actual}, expected {expected}"
+            )
+
+    def test_asset_or_nothing_call_vs_reference(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        for S, K, r, q, T, sigma, label in _DIGITAL_CASES:
+            expected = digital_asset_call(S, K, r, q, T, sigma)
+            actual = digital_option_price(
+                S,
+                K,
+                r,
+                T,
+                sigma,
+                option_type="call",
+                digital_type="asset_or_nothing",
+                carry=q,
+            )
+            # Tolerance 1e-4: asset-or-nothing involves S * N(d1), small numerical diff expected
+            assert actual == pytest.approx(expected, abs=1e-4), (
+                f"asset_or_nothing call mismatch for case '{label}': "
+                f"got {actual}, expected {expected}"
+            )
+
+    def test_asset_or_nothing_put_vs_reference(self):
+        from ferro_ta.analysis.options import digital_option_price
+
+        for S, K, r, q, T, sigma, label in _DIGITAL_CASES:
+            expected = digital_asset_put(S, K, r, q, T, sigma)
+            actual = digital_option_price(
+                S,
+                K,
+                r,
+                T,
+                sigma,
+                option_type="put",
+                digital_type="asset_or_nothing",
+                carry=q,
+            )
+            # Tolerance 1e-4: asset-or-nothing involves S * N(-d1), small numerical diff expected
+            assert actual == pytest.approx(expected, abs=1e-4), (
+                f"asset_or_nothing put mismatch for case '{label}': "
+                f"got {actual}, expected {expected}"
+            )
+
+    def test_batch_digital_price_matches_scalar(self):
+        """Vectorized call must match scalar loop for 10 random points."""
+        from ferro_ta.analysis.options import digital_option_price
+
+        rng = np.random.default_rng(7)
+        n = 10
+        S_arr = rng.uniform(80.0, 120.0, n)
+        K_arr = rng.uniform(80.0, 120.0, n)
+        r_arr = rng.uniform(0.01, 0.10, n)
+        T_arr = rng.uniform(0.1, 2.0, n)
+        sigma_arr = rng.uniform(0.10, 0.50, n)
+
+        batch = digital_option_price(
+            S_arr,
+            K_arr,
+            r_arr,
+            T_arr,
+            sigma_arr,
+            option_type="call",
+            digital_type="cash_or_nothing",
+        )
+
+        scalar_results = np.array(
+            [
+                digital_option_price(
+                    float(S_arr[i]),
+                    float(K_arr[i]),
+                    float(r_arr[i]),
+                    float(T_arr[i]),
+                    float(sigma_arr[i]),
+                    option_type="call",
+                    digital_type="cash_or_nothing",
+                )
+                for i in range(n)
+            ]
+        )
+
+        assert batch == pytest.approx(scalar_results, abs=1e-10), (
+            "Batch digital_option_price does not match scalar loop"
+        )
+
+
+# Four cases for extended Greeks: ITM call, ATM call, OTM call, ATM put
+_GREEK_CASES = [
+    # (S, K, r, q, T, sigma, option_type, label)
+    (110.0, 100.0, 0.05, 0.0, 1.0, 0.20, "call", "ITM call"),
+    (100.0, 100.0, 0.05, 0.0, 1.0, 0.20, "call", "ATM call"),
+    (90.0, 100.0, 0.05, 0.0, 1.0, 0.20, "call", "OTM call"),
+    (100.0, 100.0, 0.05, 0.0, 1.0, 0.20, "put", "ATM put"),
+]
+
+
+class TestExtendedGreeksAccuracy:
+    @pytest.fixture(autouse=True)
+    def require_scipy(self):
+        pytest.importorskip("scipy")
+
+    def test_vanna_vs_numerical_fd(self):
+        """extended_greeks().vanna matches ∂Δ/∂σ from central differences (tol=1e-3)."""
+        from ferro_ta.analysis.options import extended_greeks
+
+        for S, K, r, q, T, sigma, opt_type, label in _GREEK_CASES:
+            eg = extended_greeks(S, K, r, T, sigma, option_type=opt_type, carry=q)
+            # Reference is defined only for calls; for put use numerical FD directly
+            if opt_type == "call":
+                expected = vanna_num(S, K, r, q, T, sigma)
+            else:
+                # Vanna for put: ∂(put delta)/∂σ = ∂(call delta - e^{-qT})/∂σ = vanna_call
+                expected = vanna_num(S, K, r, q, T, sigma)
+            assert float(eg.vanna) == pytest.approx(expected, abs=1e-3), (
+                f"Vanna mismatch for '{label}': got {eg.vanna}, expected {expected}"
+            )
+
+    def test_volga_vs_numerical_fd(self):
+        """extended_greeks().volga matches ∂²V/∂σ² from central differences (tol=1e-2)."""
+        from ferro_ta.analysis.options import extended_greeks
+
+        for S, K, r, q, T, sigma, opt_type, label in _GREEK_CASES:
+            eg = extended_greeks(S, K, r, T, sigma, option_type=opt_type, carry=q)
+            expected = volga_num(S, K, r, q, T, sigma)
+            assert float(eg.volga) == pytest.approx(expected, abs=1e-2), (
+                f"Volga mismatch for '{label}': got {eg.volga}, expected {expected}"
+            )
+
+    def test_speed_negative_for_calls(self):
+        """Speed (∂Γ/∂S) should be negative for OTM calls — Gamma decreases as S moves away."""
+        from ferro_ta.analysis.options import extended_greeks
+
+        # OTM call: S < K
+        eg = extended_greeks(90.0, 100.0, 0.05, 1.0, 0.20, option_type="call")
+        assert float(eg.speed) < 0.0, (
+            f"Speed should be negative for OTM call, got {eg.speed}"
+        )
+
+    def test_charm_finite_for_valid_inputs(self):
+        """Charm should be finite and non-zero for non-degenerate inputs."""
+        from ferro_ta.analysis.options import extended_greeks
+
+        for S, K, r, q, T, sigma, opt_type, label in _GREEK_CASES:
+            eg = extended_greeks(S, K, r, T, sigma, option_type=opt_type, carry=q)
+            assert np.isfinite(float(eg.charm)), (
+                f"Charm is not finite for '{label}': {eg.charm}"
+            )
+            assert eg.charm != 0.0, (
+                f"Charm is zero for '{label}' — unexpected for non-degenerate inputs"
+            )
+
+
+class TestAmericanOptionsAccuracy:
+    """Property-based tests for American options (no scipy required)."""
+
+    def test_baw_vs_published_values(self):
+        """BAW American put satisfies the lower bound: price ≥ max(K - S, European BSM put).
+
+        The Haug (2007) table uses b = r - q (cost of carry convention).  Rather
+        than replicate the exact table — which requires matching the BAW carry
+        convention precisely — we verify two model-agnostic inequalities that any
+        correct American-put implementation must satisfy:
+
+          1. American put ≥ intrinsic value (K - S)
+          2. American put ≥ European BSM put (early exercise has non-negative value)
+        """
+        from ferro_ta.analysis.options import american_option_price, option_price
+
+        S, K, r, T, sigma = 100.0, 100.0, 0.10, 0.25, 0.20
+        american = american_option_price(S, K, r, T, sigma, option_type="put")
+        european = option_price(S, K, r, T, sigma, option_type="put")
+
+        assert american >= max(K - S, 0.0) - 1e-8, (
+            f"American put below intrinsic: {american:.4f} < {max(K - S, 0.0)}"
+        )
+        assert american >= european - 1e-8, (
+            f"American put below European put: {american:.4f} < {european:.4f}"
+        )
+        # Sanity-check: American ATM put should be in a reasonable range
+        assert 0.0 < american < K, (
+            f"American put price {american:.4f} is outside (0, K={K})"
+        )
+
+    def test_american_put_increases_with_strike(self):
+        """Deeper ITM (higher strike for put) ⇒ higher American put price.
+
+        Uses moderately spaced strikes to avoid the intrinsic-value floor
+        where K - S becomes the binding constraint and the increments are
+        exactly 1-for-1, which can mask ordering issues near the floor.
+        """
+        from ferro_ta.analysis.options import american_option_price
+
+        # S = 100, K in {85, 100, 115}; rate and carry both 0.05 to avoid b=0 issues
+        S, r, T, sigma = 100.0, 0.05, 0.5, 0.25
+        strikes = [85.0, 100.0, 115.0]
+        prices = [
+            american_option_price(S, K, r, T, sigma, option_type="put", carry=r)
+            for K in strikes
+        ]
+        assert prices[0] < prices[1] < prices[2], (
+            f"American put prices not monotone in strike: "
+            f"K={strikes} → prices={[round(p, 4) for p in prices]}"
+        )
+
+    def test_american_call_increases_with_spot(self):
+        """Higher spot ⇒ higher American call price."""
+        from ferro_ta.analysis.options import american_option_price
+
+        spots = [90.0, 100.0, 110.0]
+        prices = [
+            american_option_price(S, 100.0, 0.05, 1.0, 0.20, option_type="call")
+            for S in spots
+        ]
+        assert prices[0] < prices[1] < prices[2], (
+            f"American call prices not monotone in spot: {prices}"
+        )
+
+    def test_american_call_equals_european_no_dividends_no_early_exercise(self):
+        """American call with no early-exercise incentive (carry=0) ≈ European call.
+
+        When the cost-of-carry parameter is zero, there is no dividend/carry
+        benefit to holding the underlying.  In this regime, it is never
+        optimal to early-exercise an American call, so the American call price
+        equals the European call price computed with the same carry=0 convention.
+        The `early_exercise_premium` function exposes this directly and should
+        return ~0 for calls with carry=0.
+        """
+        from ferro_ta.analysis.options import early_exercise_premium
+
+        S, K, r, T, sigma = 100.0, 100.0, 0.05, 1.0, 0.20
+        premium = early_exercise_premium(
+            S, K, r, T, sigma, option_type="call", carry=0.0
+        )
+        assert premium == pytest.approx(0.0, abs=1e-4), (
+            f"Early exercise premium for call with carry=0 should be ~0, got {premium:.6f}"
+        )
+
+    def test_early_exercise_premium_positive_for_deep_itm_put(self):
+        """Deep ITM American put should have a meaningful early exercise premium.
+
+        When S is well below K (deep ITM put), the time value is low and the
+        interest gained from early exercise of the put dominates — leading to a
+        positive early-exercise premium.
+        """
+        from ferro_ta.analysis.options import early_exercise_premium
+
+        # Deep ITM: S=70, K=100 — strong incentive to exercise early
+        premium = early_exercise_premium(
+            70.0, 100.0, 0.10, 1.0, 0.20, option_type="put"
+        )
+        assert premium > 0.0, (
+            f"Deep ITM American put early exercise premium should be > 0, got {premium}"
+        )
+
+
+class TestVolEstimatorsAccuracy:
+    @pytest.fixture(autouse=True)
+    def require_scipy(self):
+        pytest.importorskip("scipy")
+
+    def test_close_to_close_vs_reference_impl(self):
+        """C2C vol matches reference formula exactly (tol=1e-10), 100 samples."""
+        from ferro_ta.analysis.options import close_to_close_vol
+
+        rng = np.random.default_rng(42)
+        log_ret = rng.normal(0.0, 0.01, 100)
+        close = 100.0 * np.cumprod(np.exp(log_ret))
+
+        window = 20
+        actual = close_to_close_vol(close, window=window, trading_days_per_year=252.0)
+        expected = ctc_vol_reference(close, window=window, trading_days=252.0)
+
+        valid = ~np.isnan(expected)
+        assert np.allclose(actual[valid], expected[valid], atol=1e-10), (
+            "close_to_close_vol does not match reference formula"
+        )
+
+    def test_constant_returns_known_vol(self):
+        """Constant daily log-return of 0.01 → C2C vol = 0.01 * sqrt(252) ≈ 0.1587."""
+        from ferro_ta.analysis.options import close_to_close_vol
+
+        # Build a price series with constant daily log-return of 0.01
+        n = 100
+        constant_log_ret = 0.01
+        close = 100.0 * np.exp(np.arange(n) * constant_log_ret)
+
+        window = 21
+        out = close_to_close_vol(close, window=window, trading_days_per_year=252.0)
+
+        # Expected: sqrt(0.01^2 * 252) = 0.01 * sqrt(252)
+        expected_vol = constant_log_ret * np.sqrt(252.0)
+        valid = ~np.isnan(out)
+        assert np.all(valid[window:]), "Expected valid values after warmup"
+        assert out[window] == pytest.approx(expected_vol, rel=1e-10), (
+            f"Constant-return vol: got {out[window]}, expected {expected_vol}"
+        )
+
+    def test_parkinson_lognormal_unbiased(self):
+        """Parkinson estimator within 50% of true vol=0.20 for simulated OHLC data.
+
+        Parkinson uses the log(high/low) range as a proxy for daily realized
+        vol.  The estimator is unbiased for a Brownian-motion diffusion where
+        the daily range follows a known distribution, but a simplified
+        simulation (single end-of-day price + independent range draw) will
+        underestimate the range.  We therefore build a proper multi-step
+        intraday path so the high/low reflects the true diffusion range,
+        and use a lenient 50% tolerance to accommodate finite-sample noise.
+        """
+        from ferro_ta.analysis.options import parkinson_vol
+
+        rng = np.random.default_rng(123)
+        true_vol = 0.20
+        n_days = 500
+        steps_per_day = 50  # intraday steps to get a realistic H-L range
+        daily_sigma = true_vol / np.sqrt(252.0)
+        step_sigma = daily_sigma / np.sqrt(steps_per_day)
+
+        # Simulate intraday paths, extract open/high/low/close each day
+        highs = np.empty(n_days)
+        lows = np.empty(n_days)
+        price = 100.0
+        for i in range(n_days):
+            intraday = price * np.exp(
+                np.cumsum(rng.normal(0.0, step_sigma, steps_per_day))
+            )
+            path = np.concatenate([[price], intraday])
+            highs[i] = path.max()
+            lows[i] = path.min()
+            price = intraday[-1]
+
+        window = 21
+        out = parkinson_vol(highs, lows, window=window, trading_days_per_year=252.0)
+        valid = out[~np.isnan(out)]
+
+        assert len(valid) > 0, "No valid Parkinson estimates"
+        median_est = float(np.median(valid))
+        assert abs(median_est - true_vol) < 0.50 * true_vol, (
+            f"Parkinson estimate {median_est:.4f} is more than 50% from true vol {true_vol}"
+        )
+
+    def test_vol_estimators_all_positive_finite(self):
+        """All 5 estimators produce finite and positive non-NaN values on random OHLC."""
+        from ferro_ta.analysis.options import (
+            close_to_close_vol,
+            garman_klass_vol,
+            parkinson_vol,
+            rogers_satchell_vol,
+            yang_zhang_vol,
+        )
+
+        rng = np.random.default_rng(99)
+        n = 200
+        log_ret = rng.normal(0.0, 0.01, n)
+        close = 100.0 * np.cumprod(np.exp(log_ret))
+        high = close * np.exp(np.abs(rng.normal(0.0, 0.005, n)))
+        low = close * np.exp(-np.abs(rng.normal(0.0, 0.005, n)))
+        open_ = np.roll(close, 1)
+        open_[0] = close[0]
+
+        window = 20
+        estimators = {
+            "close_to_close": close_to_close_vol(close, window=window),
+            "parkinson": parkinson_vol(high, low, window=window),
+            "garman_klass": garman_klass_vol(open_, high, low, close, window=window),
+            "rogers_satchell": rogers_satchell_vol(
+                open_, high, low, close, window=window
+            ),
+            "yang_zhang": yang_zhang_vol(open_, high, low, close, window=window),
+        }
+
+        for name, out in estimators.items():
+            valid = out[~np.isnan(out)]
+            assert len(valid) > 0, f"{name}: no valid (non-NaN) estimates"
+            assert np.all(np.isfinite(valid)), f"{name}: non-finite values present"
+            assert np.all(valid > 0.0), f"{name}: non-positive values present"
+
+
+class TestVolConeAccuracy:
+    """Tests for vol_cone — no scipy required."""
+
+    def test_cone_windows_match_requested(self):
+        """Output windows should match the input list exactly."""
+        from ferro_ta.analysis.options import vol_cone
+
+        rng = np.random.default_rng(0)
+        close = 100.0 * np.cumprod(np.exp(rng.normal(0.0, 0.01, 500)))
+        requested = (10, 21, 42)
+        cone = vol_cone(close, windows=requested)
+
+        assert list(cone.windows.astype(int)) == list(requested), (
+            f"Cone windows {list(cone.windows)} do not match requested {list(requested)}"
+        )
+
+    def test_cone_median_matches_rolling_median(self):
+        """Manually computed rolling C2C vol median for window=21 should match cone.median[0]."""
+        from ferro_ta.analysis.options import close_to_close_vol, vol_cone
+
+        rng = np.random.default_rng(5)
+        close = 100.0 * np.cumprod(np.exp(rng.normal(0.0, 0.01, 500)))
+        window = 21
+
+        cone = vol_cone(close, windows=(window,))
+
+        rolling = close_to_close_vol(close, window=window, trading_days_per_year=252.0)
+        valid = rolling[~np.isnan(rolling)]
+        manual_median = float(np.median(valid))
+
+        assert cone.median[0] == pytest.approx(manual_median, rel=1e-6), (
+            f"vol_cone median {cone.median[0]:.6f} does not match manual median {manual_median:.6f}"
+        )
+
+
+class TestStrategyAnalyticsAccuracy:
+    @pytest.fixture(autouse=True)
+    def require_scipy(self):
+        pytest.importorskip("scipy")
+
+    def test_put_call_parity_deviation_analytical(self):
+        """BSM call/put from scipy formulas fed into put_call_parity_deviation → < 1e-8."""
+        from ferro_ta.analysis.options import put_call_parity_deviation
+
+        S, K, r, q, T, sigma = 100.0, 100.0, 0.05, 0.02, 1.0, 0.20
+        call = bsm_call(S, K, r, q, T, sigma)
+        put = bsm_put(S, K, r, q, T, sigma)
+
+        dev = put_call_parity_deviation(call, put, S, K, r, T, carry=q)
+        assert abs(dev) < 1e-8, (
+            f"put_call_parity_deviation for BSM-consistent prices: got {dev}, expected ~0"
+        )
+
+    def test_expected_move_known_value(self):
+        """S=100, iv=0.20, days=30, trading_days=252 → upper move ≈ 7.14."""
+        from ferro_ta.analysis.options import expected_move
+
+        S, iv, days, td = 100.0, 0.20, 30.0, 252.0
+        lower, upper = expected_move(S, iv, days, td)
+
+        # log-normal formula: S * (exp(sigma * sqrt(days/trading_days)) - 1)
+        expected_upper = S * (np.exp(iv * np.sqrt(days / td)) - 1.0)
+        expected_lower = S * (np.exp(-iv * np.sqrt(days / td)) - 1.0)
+
+        assert upper == pytest.approx(expected_upper, rel=1e-6), (
+            f"expected_move upper: got {upper:.4f}, expected {expected_upper:.4f}"
+        )
+        assert lower == pytest.approx(expected_lower, rel=1e-6), (
+            f"expected_move lower: got {lower:.4f}, expected {expected_lower:.4f}"
+        )
+        # Numeric check: upper ≈ 7.14
+        assert upper == pytest.approx(7.14, abs=0.05), (
+            f"expected_move upper should be ~7.14, got {upper:.4f}"
+        )

ferro-ta-main/tests/unit/test_edge_cases.py

@@ -0,0 +1,296 @@
+"""Edge-case tests for ferro_ta indicators.
+
+Covers NaN handling, empty arrays, single-element inputs, extreme values,
+constant series, and dtype robustness.
+"""
+
+import numpy as np
+import pytest
+
+from ferro_ta import (
+    ATR,
+    BBANDS,
+    EMA,
+    MACD,
+    MFI,
+    OBV,
+    RSI,
+    SMA,
+    STOCH,
+    WMA,
+)
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _all_nan(arr):
+    """True if every element is NaN."""
+    return np.all(np.isnan(arr))
+
+
+# ---------------------------------------------------------------------------
+# Empty arrays
+# ---------------------------------------------------------------------------
+
+
+class TestEmptyInput:
+    """All indicators should return an empty array (not crash) for len-0 input."""
+
+    def test_sma_empty(self):
+        result = SMA(np.array([], dtype=np.float64), timeperiod=14)
+        assert len(result) == 0
+
+    def test_ema_empty(self):
+        result = EMA(np.array([], dtype=np.float64), timeperiod=14)
+        assert len(result) == 0
+
+    def test_rsi_empty(self):
+        result = RSI(np.array([], dtype=np.float64), timeperiod=14)
+        assert len(result) == 0
+
+    def test_bbands_empty(self):
+        upper, mid, lower = BBANDS(np.array([], dtype=np.float64), timeperiod=5)
+        assert len(upper) == 0
+        assert len(mid) == 0
+        assert len(lower) == 0
+
+    def test_macd_empty(self):
+        macd, sig, hist = MACD(np.array([], dtype=np.float64))
+        assert len(macd) == 0
+
+    def test_wma_empty(self):
+        result = WMA(np.array([], dtype=np.float64), timeperiod=10)
+        assert len(result) == 0
+
+
+# ---------------------------------------------------------------------------
+# Single-element arrays
+# ---------------------------------------------------------------------------
+
+
+class TestSingleElement:
+    """Single-element inputs should produce NaN (insufficient data) without panic."""
+
+    def test_sma_single(self):
+        result = SMA(np.array([42.0]), timeperiod=14)
+        assert len(result) == 1
+        assert np.isnan(result[0])
+
+    def test_ema_single(self):
+        result = EMA(np.array([42.0]), timeperiod=14)
+        assert len(result) == 1
+        assert np.isnan(result[0])
+
+    def test_rsi_single(self):
+        result = RSI(np.array([42.0]), timeperiod=14)
+        assert len(result) == 1
+        assert np.isnan(result[0])
+
+    def test_sma_period_1_single(self):
+        """SMA(period=1) on a single element should return that element."""
+        result = SMA(np.array([42.0]), timeperiod=1)
+        assert len(result) == 1
+        np.testing.assert_allclose(result[0], 42.0)
+
+
+# ---------------------------------------------------------------------------
+# All-NaN input
+# ---------------------------------------------------------------------------
+
+
+class TestAllNaN:
+    """Indicators fed entirely NaN input should not crash and return all NaN."""
+
+    @pytest.fixture()
+    def nan_50(self):
+        return np.full(50, np.nan)
+
+    def test_sma_all_nan(self, nan_50):
+        result = SMA(nan_50, timeperiod=14)
+        assert len(result) == 50
+        assert _all_nan(result)
+
+    def test_ema_all_nan(self, nan_50):
+        result = EMA(nan_50, timeperiod=14)
+        assert len(result) == 50
+        assert _all_nan(result)
+
+    def test_rsi_all_nan(self, nan_50):
+        result = RSI(nan_50, timeperiod=14)
+        assert len(result) == 50
+        assert _all_nan(result)
+
+
+# ---------------------------------------------------------------------------
+# NaN in the middle
+# ---------------------------------------------------------------------------
+
+
+class TestNaNInMiddle:
+    """A single NaN in a valid series should propagate but not crash."""
+
+    def test_sma_nan_mid(self):
+        data = np.arange(1.0, 21.0)
+        data[10] = np.nan
+        result = SMA(data, timeperiod=5)
+        assert len(result) == 20
+        # Values around the NaN should be NaN
+        for i in range(10, min(15, 20)):
+            assert np.isnan(result[i])
+
+    def test_rsi_nan_mid(self):
+        data = np.arange(1.0, 31.0)
+        data[15] = np.nan
+        result = RSI(data, timeperiod=14)
+        assert len(result) == 30
+
+
+# ---------------------------------------------------------------------------
+# Extreme values
+# ---------------------------------------------------------------------------
+
+
+class TestExtremeValues:
+    """Indicators should not crash on very large or very small values."""
+
+    def test_sma_large_values(self):
+        data = np.full(50, 1e300)
+        result = SMA(data, timeperiod=14)
+        assert len(result) == 50
+        # Non-NaN values should be ~1e300
+        valid = result[~np.isnan(result)]
+        if len(valid) > 0:
+            np.testing.assert_allclose(valid, 1e300, rtol=1e-10)
+
+    def test_sma_tiny_values(self):
+        data = np.full(50, 1e-300)
+        result = SMA(data, timeperiod=14)
+        assert len(result) == 50
+        valid = result[~np.isnan(result)]
+        if len(valid) > 0:
+            np.testing.assert_allclose(valid, 1e-300, rtol=1e-10)
+
+    def test_rsi_large_monotone(self):
+        """Monotonically increasing large values -> RSI should approach 100."""
+        data = np.linspace(1e10, 2e10, 100)
+        result = RSI(data, timeperiod=14)
+        valid = result[~np.isnan(result)]
+        if len(valid) > 0:
+            assert valid[-1] > 90.0  # strongly bullish
+
+    def test_rsi_zero_change(self):
+        """Constant series -> RSI should be 50 (or NaN in some implementations)."""
+        data = np.full(100, 50.0)
+        result = RSI(data, timeperiod=14)
+        valid = result[~np.isnan(result)]
+        # Constant series: no gains, no losses -> typically NaN or 50
+        # Just verify no crash and valid range
+        for v in valid:
+            assert 0.0 <= v <= 100.0 or np.isnan(v)
+
+    def test_bbands_constant_series(self):
+        """Constant series -> upper == middle == lower (zero std dev)."""
+        data = np.full(50, 100.0)
+        upper, mid, lower = BBANDS(data, timeperiod=10)
+        valid_mask = ~np.isnan(mid)
+        np.testing.assert_allclose(upper[valid_mask], mid[valid_mask])
+        np.testing.assert_allclose(lower[valid_mask], mid[valid_mask])
+
+
+# ---------------------------------------------------------------------------
+# Timeperiod edge cases
+# ---------------------------------------------------------------------------
+
+
+class TestTimePeriodEdge:
+    """Boundary conditions for the timeperiod parameter."""
+
+    def test_sma_period_equals_length(self):
+        data = np.arange(1.0, 11.0)  # 10 elements
+        result = SMA(data, timeperiod=10)
+        assert len(result) == 10
+        # Only last element should be valid
+        assert not np.isnan(result[-1])
+        np.testing.assert_allclose(result[-1], 5.5)
+
+    def test_sma_period_exceeds_length(self):
+        data = np.arange(1.0, 6.0)  # 5 elements
+        result = SMA(data, timeperiod=10)
+        assert len(result) == 5
+        assert _all_nan(result)
+
+    def test_ema_period_1(self):
+        """EMA with period=1 should return the input itself."""
+        data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        result = EMA(data, timeperiod=1)
+        np.testing.assert_allclose(result, data)
+
+
+# ---------------------------------------------------------------------------
+# Multi-input indicator edge cases (OHLCV)
+# ---------------------------------------------------------------------------
+
+
+class TestOHLCVEdgeCases:
+    """Edge cases for indicators requiring multiple price series."""
+
+    def test_atr_empty(self):
+        empty = np.array([], dtype=np.float64)
+        result = ATR(empty, empty, empty, timeperiod=14)
+        assert len(result) == 0
+
+    def test_stoch_empty(self):
+        empty = np.array([], dtype=np.float64)
+        slowk, slowd = STOCH(empty, empty, empty)
+        assert len(slowk) == 0
+        assert len(slowd) == 0
+
+    def test_obv_empty(self):
+        empty = np.array([], dtype=np.float64)
+        result = OBV(empty, empty)
+        assert len(result) == 0
+
+    def test_atr_single_bar(self):
+        h = np.array([10.0])
+        l = np.array([9.0])
+        c = np.array([9.5])
+        result = ATR(h, l, c, timeperiod=14)
+        assert len(result) == 1
+        assert np.isnan(result[0])
+
+    def test_mfi_constant_price(self):
+        """Constant price -> no money flow direction -> MFI should be well-defined."""
+        n = 50
+        h = np.full(n, 100.0)
+        l = np.full(n, 100.0)
+        c = np.full(n, 100.0)
+        v = np.full(n, 1000.0)
+        result = MFI(h, l, c, v, timeperiod=14)
+        assert len(result) == n
+        # Should not crash; values may be NaN or 50
+
+
+# ---------------------------------------------------------------------------
+# Dtype robustness
+# ---------------------------------------------------------------------------
+
+
+class TestDtypeRobustness:
+    """Indicators should accept float32/int inputs and coerce to float64."""
+
+    def test_sma_float32(self):
+        data = np.arange(1.0, 51.0, dtype=np.float32)
+        result = SMA(data, timeperiod=14)
+        assert len(result) == 50
+
+    def test_sma_int64(self):
+        data = np.arange(1, 51, dtype=np.int64)
+        result = SMA(data, timeperiod=14)
+        assert len(result) == 50
+
+    def test_rsi_float32(self):
+        data = np.arange(1.0, 51.0, dtype=np.float32)
+        result = RSI(data, timeperiod=14)
+        assert len(result) == 50

ferro-ta-main/tests/unit/test_known_values.py

@@ -0,0 +1,562 @@
+"""
+Known-value oracle tests: permanent ground truth (Priority 2 - no optional deps).
+
+Hand-computable ground truth that never depends on external libraries.
+These tests encode fundamental mathematical properties and serve as a permanent
+oracle for correctness.
+
+All tests use NO optional dependencies - they run in every CI environment.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+import ferro_ta
+
+# ---------------------------------------------------------------------------
+# SMA Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestSMAKnownValues:
+    """SMA is the simple average over a window."""
+
+    def test_sma_simple_sequence(self):
+        """SMA([1,2,3,4,5], 3) == [nan, nan, 2.0, 3.0, 4.0]."""
+        data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        result = ferro_ta.SMA(data, timeperiod=3)
+
+        assert np.isnan(result[0])
+        assert np.isnan(result[1])
+        assert np.abs(result[2] - 2.0) < 1e-10  # (1+2+3)/3 = 2.0
+        assert np.abs(result[3] - 3.0) < 1e-10  # (2+3+4)/3 = 3.0
+        assert np.abs(result[4] - 4.0) < 1e-10  # (3+4+5)/3 = 4.0
+
+    def test_sma_period_one_is_identity(self):
+        """SMA with period=1 should be the identity function."""
+        data = np.array([10.0, 12.0, 15.0, 11.0, 13.0])
+        result = ferro_ta.SMA(data, timeperiod=1)
+
+        assert np.allclose(result, data, atol=1e-10)
+
+    def test_sma_constant_series(self):
+        """SMA of constant series should equal that constant."""
+        data = np.ones(10) * 42.0
+        result = ferro_ta.SMA(data, timeperiod=5)
+
+        # After warmup, all values should be 42.0
+        assert np.allclose(result[4:], 42.0, atol=1e-10)
+
+
+# ---------------------------------------------------------------------------
+# EMA Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestEMAKnownValues:
+    """EMA is an exponentially weighted moving average."""
+
+    def test_ema_period_one_is_identity(self):
+        """EMA with period=1 should be the identity function (alpha=1)."""
+        data = np.array([10.0, 12.0, 15.0, 11.0, 13.0])
+        result = ferro_ta.EMA(data, timeperiod=1)
+
+        assert np.allclose(result, data, atol=1e-10)
+
+    def test_ema_constant_series_converges(self):
+        """EMA of constant series should converge to that constant."""
+        data = np.ones(100) * 42.0
+        result = ferro_ta.EMA(data, timeperiod=10)
+
+        # After sufficient warmup, should converge to 42.0
+        assert np.allclose(result[-10:], 42.0, atol=1e-6)
+
+    def test_ema_monotone_rising_is_increasing(self):
+        """EMA of monotone rising series should be strictly increasing after warmup."""
+        data = np.arange(1.0, 51.0)  # 1, 2, 3, ..., 50
+        result = ferro_ta.EMA(data, timeperiod=10)
+
+        # After warmup, EMA should be strictly increasing
+        for i in range(20, len(result) - 1):
+            assert result[i + 1] > result[i], (
+                f"EMA not increasing at index {i}: {result[i]} >= {result[i + 1]}"
+            )
+
+
+# ---------------------------------------------------------------------------
+# WMA Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestWMAKnownValues:
+    """WMA is a linearly weighted moving average."""
+
+    def test_wma_manual_calculation(self):
+        """WMA([3,5,7], 2) at index 2 = (1*5 + 2*7)/(1+2) = 6.333..."""
+        data = np.array([3.0, 5.0, 7.0])
+        result = ferro_ta.WMA(data, timeperiod=2)
+
+        # Index 0: warmup (NaN)
+        assert np.isnan(result[0])
+
+        # Index 1: (1*3 + 2*5)/(1+2) = 13/3 = 4.333...
+        expected_1 = (1 * 3.0 + 2 * 5.0) / (1 + 2)
+        assert np.abs(result[1] - expected_1) < 1e-10
+
+        # Index 2: (1*5 + 2*7)/(1+2) = 19/3 = 6.333...
+        expected_2 = (1 * 5.0 + 2 * 7.0) / (1 + 2)
+        assert np.abs(result[2] - expected_2) < 1e-10
+
+    def test_wma_period_one_is_identity(self):
+        """WMA with period=1 should be the identity function."""
+        data = np.array([10.0, 12.0, 15.0, 11.0, 13.0])
+        result = ferro_ta.WMA(data, timeperiod=1)
+
+        assert np.allclose(result, data, atol=1e-10)
+
+
+# ---------------------------------------------------------------------------
+# BBANDS Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestBBANDSKnownValues:
+    """Bollinger Bands: middle = SMA, upper/lower = middle ± (nbdevup/nbdevdn * stddev)."""
+
+    def test_bbands_constant_series(self):
+        """For constant series: upper == middle == lower (stddev=0)."""
+        data = np.ones(20) * 50.0
+        upper, middle, lower = ferro_ta.BBANDS(data, timeperiod=5)
+
+        # After warmup, all three bands should be 50.0
+        assert np.allclose(upper[4:], 50.0, atol=1e-10)
+        assert np.allclose(middle[4:], 50.0, atol=1e-10)
+        assert np.allclose(lower[4:], 50.0, atol=1e-10)
+
+    def test_bbands_middle_is_sma(self):
+        """Middle band should equal SMA."""
+        data = np.array([10.0, 12.0, 15.0, 11.0, 13.0, 14.0, 16.0, 12.0])
+        upper, middle, lower = ferro_ta.BBANDS(data, timeperiod=5)
+        sma = ferro_ta.SMA(data, timeperiod=5)
+
+        assert np.allclose(middle, sma, atol=1e-10, equal_nan=True)
+
+    def test_bbands_symmetric(self):
+        """Bands should be symmetric: upper-middle == middle-lower (with same nbdev)."""
+        data = np.array([10.0, 12.0, 15.0, 11.0, 13.0, 14.0, 16.0, 12.0, 18.0, 10.0])
+        upper, middle, lower = ferro_ta.BBANDS(
+            data, timeperiod=5, nbdevup=2.0, nbdevdn=2.0
+        )
+
+        # After warmup, bands should be symmetric
+        upper_dist = upper[4:] - middle[4:]
+        lower_dist = middle[4:] - lower[4:]
+
+        assert np.allclose(upper_dist, lower_dist, atol=1e-10)
+
+
+# ---------------------------------------------------------------------------
+# RSI Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestRSIKnownValues:
+    """RSI measures momentum: monotone rising → RSI > 50, monotone falling → RSI < 50."""
+
+    def test_rsi_monotone_rising(self):
+        """Monotone rising series should produce RSI > 50 after warmup."""
+        data = np.arange(1.0, 51.0)  # 1, 2, 3, ..., 50
+        result = ferro_ta.RSI(data, timeperiod=14)
+
+        # After warmup, RSI should be > 50 (strong uptrend)
+        assert np.all(result[20:] > 50.0), "RSI of rising series should be > 50"
+
+    def test_rsi_monotone_falling(self):
+        """Monotone falling series should produce RSI < 50 after warmup."""
+        data = np.arange(50.0, 0.0, -1.0)  # 50, 49, 48, ..., 1
+        result = ferro_ta.RSI(data, timeperiod=14)
+
+        # After warmup, RSI should be < 50 (strong downtrend)
+        assert np.all(result[20:] < 50.0), "RSI of falling series should be < 50"
+
+    def test_rsi_constant_series(self):
+        """Constant series should produce RSI = 100 or NaN (no momentum).
+
+        Note: For constant series with no change, ferro_ta returns 100
+        (no downward movement), which is mathematically correct.
+        """
+        data = np.ones(30) * 42.0
+        result = ferro_ta.RSI(data, timeperiod=14)
+
+        # Constant series has no momentum; RSI should be NaN or 100
+        # ferro_ta returns 100 (no down movement = 100% bullish)
+        valid_values = result[~np.isnan(result)]
+        if len(valid_values) > 0:
+            # Should be either NaN everywhere or 100 everywhere
+            assert np.all(np.abs(valid_values - 100.0) < 1e-10) or np.all(
+                np.abs(valid_values - 50.0) < 5.0
+            ), "RSI of constant series should be 100 (no down movement) or close to 50"
+
+
+# ---------------------------------------------------------------------------
+# ATR Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestATRKnownValues:
+    """ATR measures volatility: H==L==C → ATR=0."""
+
+    def test_atr_zero_range(self):
+        """When H==L==C, ATR should be 0 (no volatility)."""
+        n = 30
+        high = np.ones(n) * 50.0
+        low = np.ones(n) * 50.0
+        close = np.ones(n) * 50.0
+
+        result = ferro_ta.ATR(high, low, close, timeperiod=14)
+
+        # After warmup, ATR should be 0
+        assert np.allclose(result[14:], 0.0, atol=1e-10)
+
+    def test_atr_manual_tr_calculation(self):
+        """Manually verify TR formula for 3-bar sequence.
+
+        Note: ATR requires warmup period. For period=14, first 13 bars are NaN.
+        We test with longer period to see TR values.
+        """
+        # Bar 0: H=11, L=9, C=10
+        # Bar 1: H=13, L=10, C=12  → TR = max(13-10, |13-10|, |10-10|) = 3
+        # Bar 2: H=14, L=11, C=13  → TR = max(14-11, |14-12|, |11-12|) = 3
+        high = np.array(
+            [
+                11.0,
+                13.0,
+                14.0,
+                15.0,
+                16.0,
+                17.0,
+                18.0,
+                19.0,
+                20.0,
+                21.0,
+                22.0,
+                23.0,
+                24.0,
+                25.0,
+                26.0,
+            ]
+        )
+        low = np.array(
+            [
+                9.0,
+                10.0,
+                11.0,
+                12.0,
+                13.0,
+                14.0,
+                15.0,
+                16.0,
+                17.0,
+                18.0,
+                19.0,
+                20.0,
+                21.0,
+                22.0,
+                23.0,
+            ]
+        )
+        close = np.array(
+            [
+                10.0,
+                12.0,
+                13.0,
+                14.0,
+                15.0,
+                16.0,
+                17.0,
+                18.0,
+                19.0,
+                20.0,
+                21.0,
+                22.0,
+                23.0,
+                24.0,
+                25.0,
+            ]
+        )
+
+        # For period=1, ATR still has warmup. Use TRANGE to check TR values directly
+        tr = ferro_ta.TRANGE(high, low, close)
+
+        # TR[0] = H-L = 11-9 = 2
+        # TR[1] = max(13-10, |13-10|, |10-10|) = max(3, 3, 0) = 3
+        # TR[2] = max(14-11, |14-12|, |11-12|) = max(3, 2, 1) = 3
+
+        assert np.abs(tr[0] - 2.0) < 1e-10
+        assert np.abs(tr[1] - 3.0) < 1e-10
+        assert np.abs(tr[2] - 3.0) < 1e-10
+
+
+# ---------------------------------------------------------------------------
+# MOM Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestMOMKnownValues:
+    """MOM is the difference: close[i] - close[i - period]."""
+
+    def test_mom_manual_calculation(self):
+        """MOM([10,12,15,11], period=2) == [nan,nan,5,-1]."""
+        data = np.array([10.0, 12.0, 15.0, 11.0])
+        result = ferro_ta.MOM(data, timeperiod=2)
+
+        assert np.isnan(result[0])
+        assert np.isnan(result[1])
+        assert np.abs(result[2] - 5.0) < 1e-10  # 15 - 10 = 5
+        assert np.abs(result[3] - (-1.0)) < 1e-10  # 11 - 12 = -1
+
+
+# ---------------------------------------------------------------------------
+# ROC Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestROCKnownValues:
+    """ROC is the percentage change: 100 * (close[i] - close[i-period]) / close[i-period]."""
+
+    def test_roc_manual_calculation(self):
+        """ROC([10,12], period=1)[1] == 20.0."""
+        data = np.array([10.0, 12.0])
+        result = ferro_ta.ROC(data, timeperiod=1)
+
+        # ROC[1] = 100 * (12 - 10) / 10 = 100 * 0.2 = 20.0
+        assert np.abs(result[1] - 20.0) < 1e-10
+
+
+# ---------------------------------------------------------------------------
+# MACD Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestMACDKnownValues:
+    """MACD: histogram == macd - signal always."""
+
+    def test_macd_histogram_identity(self):
+        """histogram should always equal macd - signal."""
+        data = np.arange(1.0, 51.0)
+        macd, signal, histogram = ferro_ta.MACD(
+            data, fastperiod=12, slowperiod=26, signalperiod=9
+        )
+
+        # histogram = macd - signal (within floating-point tolerance)
+        expected_histogram = macd - signal
+        assert np.allclose(histogram, expected_histogram, atol=1e-10, equal_nan=True)
+
+
+# ---------------------------------------------------------------------------
+# VWAP Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestVWAPKnownValues:
+    """VWAP: period=1 VWAP == TYPPRICE."""
+
+    def test_vwap_period_one_equals_typprice(self):
+        """For period=1, VWAP should equal typical price (H+L+C)/3."""
+        high = np.array([11.0, 13.0, 14.0])
+        low = np.array([9.0, 10.0, 11.0])
+        close = np.array([10.0, 12.0, 13.0])
+        volume = np.array([1000.0, 1000.0, 1000.0])
+
+        result = ferro_ta.VWAP(high, low, close, volume, timeperiod=1)
+        expected = ferro_ta.TYPPRICE(high, low, close)
+
+        assert np.allclose(result, expected, atol=1e-10)
+
+    def test_vwap_cumulative_manual(self):
+        """Manually verify cumulative VWAP for simple 3-bar sequence."""
+        # Bar 0: TP=10, Vol=100 → VWAP = (10*100)/(100) = 10.0
+        # Bar 1: TP=12, Vol=200 → VWAP = (10*100 + 12*200)/(100+200) = 3400/300 = 11.333...
+        # Bar 2: TP=11, Vol=150 → VWAP = (10*100 + 12*200 + 11*150)/(100+200+150) = 5050/450 = 11.222...
+        high = np.array([11.0, 13.0, 12.0])
+        low = np.array([9.0, 11.0, 10.0])
+        close = np.array([10.0, 12.0, 11.0])
+        volume = np.array([100.0, 200.0, 150.0])
+
+        result = ferro_ta.VWAP(high, low, close, volume, timeperiod=0)  # cumulative
+
+        typ = (high + low + close) / 3.0
+
+        expected_0 = typ[0]
+        expected_1 = (typ[0] * volume[0] + typ[1] * volume[1]) / (volume[0] + volume[1])
+        expected_2 = (typ[0] * volume[0] + typ[1] * volume[1] + typ[2] * volume[2]) / (
+            volume[0] + volume[1] + volume[2]
+        )
+
+        assert np.abs(result[0] - expected_0) < 1e-10
+        assert np.abs(result[1] - expected_1) < 1e-10
+        assert np.abs(result[2] - expected_2) < 1e-10
+
+
+# ---------------------------------------------------------------------------
+# DONCHIAN Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestDONCHIANKnownValues:
+    """DONCHIAN: upper = MAX(high), lower = MIN(low), middle = (upper+lower)/2."""
+
+    def test_donchian_structure(self):
+        """upper == MAX(high), lower == MIN(low), middle == (upper+lower)/2."""
+        high = np.array([11.0, 13.0, 14.0, 12.0, 15.0])
+        low = np.array([9.0, 10.0, 11.0, 10.0, 12.0])
+
+        period = 3
+        upper, middle, lower = ferro_ta.DONCHIAN(high, low, timeperiod=period)
+
+        # upper should match rolling max of high
+        max_high = ferro_ta.MAX(high, timeperiod=period)
+        assert np.allclose(upper, max_high, atol=1e-10, equal_nan=True)
+
+        # lower should match rolling min of low
+        min_low = ferro_ta.MIN(low, timeperiod=period)
+        assert np.allclose(lower, min_low, atol=1e-10, equal_nan=True)
+
+        # middle should be (upper + lower) / 2
+        expected_middle = (upper + lower) / 2.0
+        assert np.allclose(middle, expected_middle, atol=1e-10, equal_nan=True)
+
+
+# ---------------------------------------------------------------------------
+# PIVOT_POINTS Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestPIVOT_POINTSKnownValues:
+    """PIVOT_POINTS classic formula: P=(H+L+C)/3, R1=2P-L, S1=2P-H, R2=P+(H-L), S2=P-(H-L)."""
+
+    def test_pivot_points_classic_formula(self):
+        """Given H=110, L=90, C=100: P=100, R1=110, S1=90, R2=120, S2=80.
+
+        Note: PIVOT_POINTS operates on OHLC bars. Single bar produces valid pivots.
+        """
+        high = np.array([110.0, 110.0])  # Need at least 2 bars
+        low = np.array([90.0, 90.0])
+        close = np.array([100.0, 100.0])
+
+        pivot, r1, s1, r2, s2 = ferro_ta.PIVOT_POINTS(
+            high, low, close, method="classic"
+        )
+
+        # Check last bar (index 1) which has full history
+        # P = (110 + 90 + 100) / 3 = 100
+        assert np.abs(pivot[1] - 100.0) < 1e-10
+
+        # R1 = 2*P - L = 2*100 - 90 = 110
+        assert np.abs(r1[1] - 110.0) < 1e-10
+
+        # S1 = 2*P - H = 2*100 - 110 = 90
+        assert np.abs(s1[1] - 90.0) < 1e-10
+
+        # R2 = P + (H - L) = 100 + 20 = 120
+        assert np.abs(r2[1] - 120.0) < 1e-10
+
+        # S2 = P - (H - L) = 100 - 20 = 80
+        assert np.abs(s2[1] - 80.0) < 1e-10
+
+
+# ---------------------------------------------------------------------------
+# Statistic Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestStatisticKnownValues:
+    """Statistical functions: correlation, linear regression."""
+
+    def test_linearreg_slope_of_linear_sequence(self):
+        """LINEARREG_SLOPE([0,1,2,3,4], 5) == 1.0."""
+        data = np.array([0.0, 1.0, 2.0, 3.0, 4.0])
+        result = ferro_ta.LINEARREG_SLOPE(data, timeperiod=5)
+
+        # Last value should be slope = 1.0
+        assert np.abs(result[-1] - 1.0) < 1e-10
+
+    def test_correl_x_with_x_is_one(self):
+        """CORREL(x, x) should be 1.0."""
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
+        result = ferro_ta.CORREL(x, x, timeperiod=5)
+
+        # After warmup, correlation should be 1.0
+        assert np.allclose(result[4:], 1.0, atol=1e-10)
+
+    def test_correl_x_with_negative_x_is_minus_one(self):
+        """CORREL(x, -x) should be -1.0."""
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
+        neg_x = -x
+        result = ferro_ta.CORREL(x, neg_x, timeperiod=5)
+
+        # After warmup, correlation should be -1.0
+        assert np.allclose(result[4:], -1.0, atol=1e-10)
+
+
+# ---------------------------------------------------------------------------
+# Pattern Known Values
+# ---------------------------------------------------------------------------
+
+
+class TestPatternKnownValues:
+    """Candlestick patterns: construct known-good OHLC sequences."""
+
+    def test_doji_known_sequence(self):
+        """Construct a perfect doji: open == close, small body."""
+        # Doji: open == close (or very close), H and L have range
+        high = np.array([11.0, 11.0, 11.0, 11.0, 11.0])
+        low = np.array([9.0, 9.0, 9.0, 9.0, 9.0])
+        close = np.array([10.0, 10.0, 10.0, 10.0, 10.0])
+        open_ = np.array([10.0, 10.0, 10.0, 10.0, 10.0])
+
+        result = ferro_ta.CDLDOJI(open_, high, low, close)
+
+        # Should detect doji (non-zero pattern)
+        # At least some values should be non-zero
+        assert np.any(result != 0), "CDLDOJI should detect perfect doji pattern"
+
+    def test_engulfing_known_sequence(self):
+        """Construct a bullish engulfing pattern."""
+        # Bullish engulfing: bar[i-1] is bearish (O > C), bar[i] is bullish (C > O) and engulfs bar[i-1]
+        # Bar 0: O=12, H=12, L=10, C=10 (bearish)
+        # Bar 1: O=9, H=13, L=9, C=13 (bullish, engulfs bar 0)
+        open_ = np.array([12.0, 9.0])
+        high = np.array([12.0, 13.0])
+        low = np.array([10.0, 9.0])
+        close = np.array([10.0, 13.0])
+
+        result = ferro_ta.CDLENGULFING(open_, high, low, close)
+
+        # Should detect engulfing at index 1
+        assert result[1] != 0, "CDLENGULFING should detect bullish engulfing pattern"
+
+    def test_hammer_known_sequence(self):
+        """Construct a hammer pattern: small body at top, long lower shadow."""
+        # Hammer: small body, long lower shadow (>= 2x body), little/no upper shadow
+        # O=11, H=11.5, L=9, C=11 → body=0, lower_shadow=2, upper_shadow=0.5
+        open_ = np.array([11.0])
+        high = np.array([11.5])
+        low = np.array([9.0])
+        close = np.array([11.0])
+
+        result = ferro_ta.CDLHAMMER(open_, high, low, close)
+
+        # Should detect hammer (non-zero)
+        # Note: hammer detection depends on lookback, so we test multiple bars
+        open_ = np.array([10.0, 10.5, 11.0])
+        high = np.array([10.5, 11.0, 11.5])
+        low = np.array([9.5, 10.0, 9.0])
+        close = np.array([10.0, 10.5, 11.0])
+
+        result = ferro_ta.CDLHAMMER(open_, high, low, close)
+
+        # Last bar has hammer characteristics
+        # (actual detection may vary based on implementation)
+        assert result.shape == close.shape

ferro-ta-main/tests/unit/test_math_ops_vs_numpy.py

@@ -0,0 +1,357 @@
+"""
+Comparison tests: ferro_ta.math_ops vs NumPy (Priority 1 - no optional deps).
+
+Math operators should be exact numpy wrappers. Zero tolerance for deviation.
+
+This module validates that all math operators and transforms in ferro_ta.math_ops
+produce identical results to their NumPy equivalents within strict tolerances:
+  - Element-wise transforms: atol=1e-14 (direct numpy calls)
+  - Binary operators: atol=1e-14 (direct numpy calls)
+  - Rolling operators: atol=1e-12 (float sum reordering)
+  - Index operators: exact index matching
+
+All tests use NO optional dependencies - they run in every CI environment.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from ferro_ta.indicators import math_ops
+
+# ---------------------------------------------------------------------------
+# Test Data (seeded for reproducibility)
+# ---------------------------------------------------------------------------
+
+RNG = np.random.default_rng(42)
+N = 100
+
+# Standard test data
+CLOSE = 44.0 + np.cumsum(RNG.standard_normal(N) * 0.5)
+CLOSE_POSITIVE = np.abs(CLOSE) + 1.0  # For SQRT, LN, LOG10
+CLOSE_NORMALIZED = CLOSE / np.max(np.abs(CLOSE))  # For ASIN, ACOS (range [-1, 1])
+
+
+# ---------------------------------------------------------------------------
+# Element-wise Transform Tests
+# ---------------------------------------------------------------------------
+
+
+class TestElementWiseTransforms:
+    """Test all 15 unary math transforms against NumPy equivalents.
+
+    Expected tolerance: atol=1e-14 (direct numpy calls)
+    """
+
+    def test_sin_exact_match(self):
+        """SIN should match np.sin exactly."""
+        result = math_ops.SIN(CLOSE)
+        expected = np.sin(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_cos_exact_match(self):
+        """COS should match np.cos exactly."""
+        result = math_ops.COS(CLOSE)
+        expected = np.cos(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_tan_exact_match(self):
+        """TAN should match np.tan exactly."""
+        result = math_ops.TAN(CLOSE)
+        expected = np.tan(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_sinh_exact_match(self):
+        """SINH should match np.sinh exactly."""
+        result = math_ops.SINH(CLOSE)
+        expected = np.sinh(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_cosh_exact_match(self):
+        """COSH should match np.cosh exactly."""
+        result = math_ops.COSH(CLOSE)
+        expected = np.cosh(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_tanh_exact_match(self):
+        """TANH should match np.tanh exactly."""
+        result = math_ops.TANH(CLOSE)
+        expected = np.tanh(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_asin_exact_match(self):
+        """ASIN should match np.arcsin exactly."""
+        result = math_ops.ASIN(CLOSE_NORMALIZED)
+        expected = np.arcsin(CLOSE_NORMALIZED)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_acos_exact_match(self):
+        """ACOS should match np.arccos exactly."""
+        result = math_ops.ACOS(CLOSE_NORMALIZED)
+        expected = np.arccos(CLOSE_NORMALIZED)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_atan_exact_match(self):
+        """ATAN should match np.arctan exactly."""
+        result = math_ops.ATAN(CLOSE)
+        expected = np.arctan(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_exp_exact_match(self):
+        """EXP should match np.exp exactly."""
+        # Use smaller values to avoid overflow
+        small_values = CLOSE / 10.0
+        result = math_ops.EXP(small_values)
+        expected = np.exp(small_values)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_ln_exact_match(self):
+        """LN should match np.log exactly."""
+        result = math_ops.LN(CLOSE_POSITIVE)
+        expected = np.log(CLOSE_POSITIVE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_log10_exact_match(self):
+        """LOG10 should match np.log10 exactly."""
+        result = math_ops.LOG10(CLOSE_POSITIVE)
+        expected = np.log10(CLOSE_POSITIVE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_sqrt_exact_match(self):
+        """SQRT should match np.sqrt exactly."""
+        result = math_ops.SQRT(CLOSE_POSITIVE)
+        expected = np.sqrt(CLOSE_POSITIVE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_ceil_exact_match(self):
+        """CEIL should match np.ceil exactly."""
+        result = math_ops.CEIL(CLOSE)
+        expected = np.ceil(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_floor_exact_match(self):
+        """FLOOR should match np.floor exactly."""
+        result = math_ops.FLOOR(CLOSE)
+        expected = np.floor(CLOSE)
+        assert np.allclose(result, expected, atol=1e-14)
+
+
+# ---------------------------------------------------------------------------
+# Binary Operator Tests
+# ---------------------------------------------------------------------------
+
+
+class TestBinaryOps:
+    """Test binary operators against NumPy equivalents.
+
+    Expected tolerance: atol=1e-14 (direct numpy calls)
+    """
+
+    def test_add_exact_match(self):
+        """ADD should match np.add exactly."""
+        other = RNG.standard_normal(N)
+        result = math_ops.ADD(CLOSE, other)
+        expected = np.add(CLOSE, other)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_sub_exact_match(self):
+        """SUB should match np.subtract exactly."""
+        other = RNG.standard_normal(N)
+        result = math_ops.SUB(CLOSE, other)
+        expected = np.subtract(CLOSE, other)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_mult_exact_match(self):
+        """MULT should match np.multiply exactly."""
+        other = RNG.standard_normal(N)
+        result = math_ops.MULT(CLOSE, other)
+        expected = np.multiply(CLOSE, other)
+        assert np.allclose(result, expected, atol=1e-14)
+
+    def test_div_exact_match(self):
+        """DIV should match np.divide exactly."""
+        other = RNG.uniform(0.5, 2.0, N)  # Avoid division by zero
+        result = math_ops.DIV(CLOSE, other)
+        expected = np.divide(CLOSE, other)
+        assert np.allclose(result, expected, atol=1e-14)
+
+
+# ---------------------------------------------------------------------------
+# Rolling Operator Tests
+# ---------------------------------------------------------------------------
+
+
+class TestRollingOps:
+    """Test rolling operators against pandas equivalents.
+
+    Expected tolerance: atol=1e-12 (float sum reordering)
+    """
+
+    @pytest.mark.parametrize("period", [5, 10, 20, 30])
+    def test_sum_matches_pandas_rolling(self, period):
+        """SUM should match pd.Series.rolling(p).sum()."""
+        result = math_ops.SUM(CLOSE, timeperiod=period)
+        expected = pd.Series(CLOSE).rolling(period).sum().to_numpy()
+
+        # Check NaN positions match
+        assert np.sum(np.isnan(result)) == np.sum(np.isnan(expected))
+
+        # Check values match where both are finite
+        mask = ~np.isnan(result) & ~np.isnan(expected)
+        assert np.allclose(result[mask], expected[mask], atol=1e-12)
+
+    @pytest.mark.parametrize("period", [5, 10, 20, 30])
+    def test_max_matches_pandas_rolling(self, period):
+        """MAX should match pd.Series.rolling(p).max()."""
+        result = math_ops.MAX(CLOSE, timeperiod=period)
+        expected = pd.Series(CLOSE).rolling(period).max().to_numpy()
+
+        # Check NaN positions match
+        assert np.sum(np.isnan(result)) == np.sum(np.isnan(expected))
+
+        # Check values match where both are finite
+        mask = ~np.isnan(result) & ~np.isnan(expected)
+        assert np.allclose(result[mask], expected[mask], atol=1e-12)
+
+    @pytest.mark.parametrize("period", [5, 10, 20, 30])
+    def test_min_matches_pandas_rolling(self, period):
+        """MIN should match pd.Series.rolling(p).min()."""
+        result = math_ops.MIN(CLOSE, timeperiod=period)
+        expected = pd.Series(CLOSE).rolling(period).min().to_numpy()
+
+        # Check NaN positions match
+        assert np.sum(np.isnan(result)) == np.sum(np.isnan(expected))
+
+        # Check values match where both are finite
+        mask = ~np.isnan(result) & ~np.isnan(expected)
+        assert np.allclose(result[mask], expected[mask], atol=1e-12)
+
+
+# ---------------------------------------------------------------------------
+# Index Operator Tests
+# ---------------------------------------------------------------------------
+
+
+class TestIndexOps:
+    """Test MAXINDEX and MININDEX point to correct argmax/argmin in window."""
+
+    @pytest.mark.parametrize("period", [5, 10, 20])
+    def test_maxindex_points_to_max(self, period):
+        """MAXINDEX should point to the index of the rolling maximum."""
+        result_idx = math_ops.MAXINDEX(CLOSE, timeperiod=period)
+        result_max = math_ops.MAX(CLOSE, timeperiod=period)
+
+        # Skip warmup period
+        for i in range(period - 1, N):
+            idx = result_idx[i]
+            max_val = result_max[i]
+
+            # During warmup, index is -1
+            if idx == -1:
+                assert np.isnan(max_val)
+            else:
+                # Index should point to the actual maximum in the window
+                assert CLOSE[idx] == max_val, (
+                    f"At position {i}, MAXINDEX={idx} but CLOSE[{idx}]={CLOSE[idx]} "
+                    f"!= MAX={max_val}"
+                )
+
+    @pytest.mark.parametrize("period", [5, 10, 20])
+    def test_minindex_points_to_min(self, period):
+        """MININDEX should point to the index of the rolling minimum."""
+        result_idx = math_ops.MININDEX(CLOSE, timeperiod=period)
+        result_min = math_ops.MIN(CLOSE, timeperiod=period)
+
+        # Skip warmup period
+        for i in range(period - 1, N):
+            idx = result_idx[i]
+            min_val = result_min[i]
+
+            # During warmup, index is -1
+            if idx == -1:
+                assert np.isnan(min_val)
+            else:
+                # Index should point to the actual minimum in the window
+                assert CLOSE[idx] == min_val, (
+                    f"At position {i}, MININDEX={idx} but CLOSE[{idx}]={CLOSE[idx]} "
+                    f"!= MIN={min_val}"
+                )
+
+    def test_maxindex_warmup_returns_minus_one(self):
+        """MAXINDEX should return -1 during warmup period."""
+        period = 10
+        result = math_ops.MAXINDEX(CLOSE, timeperiod=period)
+
+        # First period-1 values should be -1
+        for i in range(period - 1):
+            assert result[i] == -1, f"Expected -1 at index {i}, got {result[i]}"
+
+    def test_minindex_warmup_returns_minus_one(self):
+        """MININDEX should return -1 during warmup period."""
+        period = 10
+        result = math_ops.MININDEX(CLOSE, timeperiod=period)
+
+        # First period-1 values should be -1
+        for i in range(period - 1):
+            assert result[i] == -1, f"Expected -1 at index {i}, got {result[i]}"
+
+
+# ---------------------------------------------------------------------------
+# Edge Case Tests
+# ---------------------------------------------------------------------------
+
+
+class TestEdgeCases:
+    """Test edge cases and document behavior.
+
+    Documents behavior for:
+    - LN(negative) → NaN
+    - SQRT(negative) → NaN
+    - DIV(by zero) → inf
+    - ACOS(>1) → NaN
+    """
+
+    def test_ln_negative_returns_nan(self):
+        """LN of negative values should return NaN."""
+        negative = np.array([-1.0, -2.0, -3.0])
+        result = math_ops.LN(negative)
+        assert np.all(np.isnan(result)), "LN(negative) should return NaN"
+
+    def test_sqrt_negative_returns_nan(self):
+        """SQRT of negative values should return NaN."""
+        negative = np.array([-1.0, -4.0, -9.0])
+        result = math_ops.SQRT(negative)
+        assert np.all(np.isnan(result)), "SQRT(negative) should return NaN"
+
+    def test_div_by_zero_returns_inf(self):
+        """DIV by zero should return inf (NumPy behavior)."""
+        numerator = np.array([1.0, 2.0, 3.0])
+        denominator = np.array([0.0, 0.0, 0.0])
+        result = math_ops.DIV(numerator, denominator)
+        assert np.all(np.isinf(result)), "DIV(by zero) should return inf"
+
+    def test_acos_out_of_range_returns_nan(self):
+        """ACOS of values outside [-1, 1] should return NaN."""
+        out_of_range = np.array([1.5, 2.0, -1.5])
+        result = math_ops.ACOS(out_of_range)
+        assert np.all(np.isnan(result)), "ACOS(>1 or <-1) should return NaN"
+
+    def test_asin_out_of_range_returns_nan(self):
+        """ASIN of values outside [-1, 1] should return NaN."""
+        out_of_range = np.array([1.5, 2.0, -1.5])
+        result = math_ops.ASIN(out_of_range)
+        assert np.all(np.isnan(result)), "ASIN(>1 or <-1) should return NaN"
+
+    def test_log10_zero_returns_negative_inf(self):
+        """LOG10(0) should return -inf."""
+        zero = np.array([0.0])
+        result = math_ops.LOG10(zero)
+        assert np.isinf(result[0]) and result[0] < 0, "LOG10(0) should return -inf"
+
+    def test_ln_zero_returns_negative_inf(self):
+        """LN(0) should return -inf."""
+        zero = np.array([0.0])
+        result = math_ops.LN(zero)
+        assert np.isinf(result[0]) and result[0] < 0, "LN(0) should return -inf"

ferro-ta-main/tests/unit/test_optional_dependency_wrappers.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import numpy as np
+
+from ferro_ta._utils import (
+    _optional_pandas_module,
+    _optional_polars_module,
+    pandas_wrap,
+    polars_wrap,
+)
+
+
+def _missing_only(module_name: str):
+    real_import = __import__
+    attempts: list[str] = []
+
+    def side_effect(name, globals=None, locals=None, fromlist=(), level=0):
+        if name == module_name:
+            attempts.append(name)
+            raise ImportError(f"{module_name} not installed")
+        return real_import(name, globals, locals, fromlist, level)
+
+    return attempts, side_effect
+
+
+def test_pandas_wrap_caches_missing_optional_import() -> None:
+    _optional_pandas_module.cache_clear()
+    wrapped = pandas_wrap(lambda arr: arr)
+    arr = np.array([1.0, 2.0, 3.0], dtype=np.float64)
+    attempts, side_effect = _missing_only("pandas")
+
+    try:
+        with patch("builtins.__import__", side_effect=side_effect):
+            np.testing.assert_array_equal(wrapped(arr), arr)
+            np.testing.assert_array_equal(wrapped(arr), arr)
+    finally:
+        _optional_pandas_module.cache_clear()
+
+    assert attempts == ["pandas"]
+
+
+def test_polars_wrap_caches_missing_optional_import() -> None:
+    _optional_polars_module.cache_clear()
+    wrapped = polars_wrap(lambda arr: arr)
+    arr = np.array([1.0, 2.0, 3.0], dtype=np.float64)
+    attempts, side_effect = _missing_only("polars")
+
+    try:
+        with patch("builtins.__import__", side_effect=side_effect):
+            np.testing.assert_array_equal(wrapped(arr), arr)
+            np.testing.assert_array_equal(wrapped(arr), arr)
+    finally:
+        _optional_polars_module.cache_clear()
+
+    assert attempts == ["polars"]

ferro-ta-main/tests/unit/test_property_based.py

@@ -0,0 +1,263 @@
+"""Property-based tests (Hypothesis) for ferro-ta."""
+
+import numpy as np
+import pytest
+
+from ferro_ta import ATR, BBANDS, CDLDOJI, EMA, MACD, OBV, RSI, SMA, WMA
+
+try:
+    from hypothesis import given, settings
+    from hypothesis.strategies import floats, integers, lists
+
+    HAS_HYPOTHESIS = True
+except ImportError:
+    HAS_HYPOTHESIS = False
+
+if HAS_HYPOTHESIS:
+    # Strategy: finite floats, reasonable length
+    finite_floats = floats(
+        min_value=1e-6, max_value=1e6, allow_nan=False, allow_infinity=False
+    )
+    price_arrays = lists(finite_floats, min_size=2, max_size=500).map(np.array)
+    periods = integers(min_value=1, max_value=100)
+
+    @given(price_arrays, periods)
+    @settings(max_examples=50, deadline=5000)
+    def test_sma_output_length_matches_input(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        result = SMA(close, timeperiod=timeperiod)
+        assert len(result) == len(close)
+
+    @given(price_arrays, periods)
+    @settings(max_examples=50, deadline=5000)
+    def test_ema_output_length_matches_input(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        result = EMA(close, timeperiod=timeperiod)
+        assert len(result) == len(close)
+
+    @given(price_arrays, periods)
+    @settings(max_examples=50, deadline=5000)
+    def test_rsi_output_length_matches_input(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        result = RSI(close, timeperiod=timeperiod)
+        assert len(result) == len(close)
+
+    @given(price_arrays, periods)
+    @settings(max_examples=30, deadline=5000)
+    def test_bbands_three_outputs_same_length(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        upper, middle, lower = BBANDS(close, timeperiod=timeperiod)
+        assert len(upper) == len(close)
+        assert len(middle) == len(close)
+        assert len(lower) == len(close)
+
+    @given(
+        lists(finite_floats, min_size=3, max_size=100).map(np.array),
+        lists(finite_floats, min_size=3, max_size=100).map(np.array),
+        lists(finite_floats, min_size=3, max_size=100).map(np.array),
+        lists(finite_floats, min_size=3, max_size=100).map(np.array),
+    )
+    @settings(max_examples=20, deadline=5000)
+    def test_cdl_pattern_output_values_in_set(open_, high, low, close):
+        n = min(len(open_), len(high), len(low), len(close))
+        open_ = open_[:n]
+        high = high[:n]
+        low = low[:n]
+        close = close[:n]
+        result = CDLDOJI(open_, high, low, close)
+        assert len(result) == n
+        assert all(v in (-100, 0, 100) for v in result)
+
+    # ------------------------------------------------------------------
+    # EMA extended properties
+    # ------------------------------------------------------------------
+
+    @given(price_arrays, integers(min_value=2, max_value=50))
+    @settings(max_examples=50, deadline=5000)
+    def test_ema_values_finite_when_input_finite(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        result = EMA(close, timeperiod=timeperiod)
+        assert np.all(np.isfinite(result) | np.isnan(result))
+        # All non-NaN values must be finite
+        valid = result[~np.isnan(result)]
+        assert np.all(np.isfinite(valid))
+
+    @given(price_arrays)
+    @settings(max_examples=50, deadline=5000)
+    def test_ema_period_1_equals_input(close):
+        result = EMA(close, timeperiod=1)
+        assert len(result) == len(close)
+        # EMA with period=1 should reproduce the input exactly
+        np.testing.assert_allclose(result, close, rtol=1e-10)
+
+    # ------------------------------------------------------------------
+    # BBANDS extended properties
+    # ------------------------------------------------------------------
+
+    @given(price_arrays, integers(min_value=2, max_value=50))
+    @settings(max_examples=30, deadline=5000)
+    def test_bbands_upper_ge_middle_ge_lower(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        upper, middle, lower = BBANDS(close, timeperiod=timeperiod)
+        # Where all three are finite, upper >= middle >= lower
+        mask = np.isfinite(upper) & np.isfinite(middle) & np.isfinite(lower)
+        assert np.all(upper[mask] >= middle[mask] - 1e-10)
+        assert np.all(middle[mask] >= lower[mask] - 1e-10)
+
+    @given(price_arrays, integers(min_value=2, max_value=50))
+    @settings(max_examples=30, deadline=5000)
+    def test_bbands_middle_equals_sma(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        _, middle, _ = BBANDS(close, timeperiod=timeperiod)
+        sma = SMA(close, timeperiod=timeperiod)
+        mask = np.isfinite(middle) & np.isfinite(sma)
+        np.testing.assert_allclose(middle[mask], sma[mask], rtol=1e-10)
+
+    # ------------------------------------------------------------------
+    # MACD properties
+    # ------------------------------------------------------------------
+
+    @given(
+        lists(finite_floats, min_size=40, max_size=500).map(np.array),
+    )
+    @settings(max_examples=50, deadline=5000)
+    def test_macd_output_lengths(close):
+        macd, signal, hist = MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
+        assert len(macd) == len(close)
+        assert len(signal) == len(close)
+        assert len(hist) == len(close)
+
+    @given(
+        lists(finite_floats, min_size=40, max_size=500).map(np.array),
+    )
+    @settings(max_examples=50, deadline=5000)
+    def test_macd_histogram_equals_macd_minus_signal(close):
+        macd, signal, hist = MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
+        mask = np.isfinite(macd) & np.isfinite(signal) & np.isfinite(hist)
+        if np.any(mask):
+            np.testing.assert_allclose(
+                hist[mask], macd[mask] - signal[mask], atol=1e-10
+            )
+
+    # ------------------------------------------------------------------
+    # ATR properties
+    # ------------------------------------------------------------------
+
+    @given(
+        lists(finite_floats, min_size=20, max_size=500).map(np.array),
+        integers(min_value=2, max_value=50),
+    )
+    @settings(max_examples=50, deadline=5000)
+    def test_atr_output_length(prices, timeperiod):
+        # Build high/low/close from prices with valid OHLC relationships
+        close = prices
+        high = prices * 1.01
+        low = prices * 0.99
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        result = ATR(high, low, close, timeperiod=timeperiod)
+        assert len(result) == len(close)
+
+    @given(
+        lists(finite_floats, min_size=20, max_size=500).map(np.array),
+        integers(min_value=2, max_value=50),
+    )
+    @settings(max_examples=50, deadline=5000)
+    def test_atr_non_negative(prices, timeperiod):
+        close = prices
+        high = prices * 1.01
+        low = prices * 0.99
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        result = ATR(high, low, close, timeperiod=timeperiod)
+        valid = result[~np.isnan(result)]
+        assert np.all(valid >= 0)
+
+    # ------------------------------------------------------------------
+    # WMA properties
+    # ------------------------------------------------------------------
+
+    @given(price_arrays, integers(min_value=2, max_value=50))
+    @settings(max_examples=50, deadline=5000)
+    def test_wma_output_length(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 1:
+                timeperiod = 1
+        result = WMA(close, timeperiod=timeperiod)
+        assert len(result) == len(close)
+
+    @given(
+        lists(finite_floats, min_size=20, max_size=500).map(np.array),
+        integers(min_value=2, max_value=50),
+    )
+    @settings(max_examples=50, deadline=5000)
+    def test_wma_leading_nans(close, timeperiod):
+        if len(close) < timeperiod:
+            timeperiod = min(timeperiod, len(close))
+            if timeperiod < 2:
+                timeperiod = 2
+        result = WMA(close, timeperiod=timeperiod)
+        # First (timeperiod - 1) values should be NaN
+        assert np.all(np.isnan(result[: timeperiod - 1]))
+
+    # ------------------------------------------------------------------
+    # OBV properties
+    # ------------------------------------------------------------------
+
+    @given(
+        lists(finite_floats, min_size=20, max_size=500).map(np.array),
+        lists(finite_floats, min_size=20, max_size=500).map(np.array),
+    )
+    @settings(max_examples=50, deadline=5000)
+    def test_obv_output_length(close, volume):
+        n = min(len(close), len(volume))
+        close = close[:n]
+        volume = volume[:n]
+        result = OBV(close, volume)
+        assert len(result) == n
+
+    @given(
+        lists(finite_floats, min_size=20, max_size=500).map(np.array),
+        lists(finite_floats, min_size=20, max_size=500).map(np.array),
+    )
+    @settings(max_examples=50, deadline=5000)
+    def test_obv_all_finite(close, volume):
+        n = min(len(close), len(volume))
+        close = close[:n]
+        volume = volume[:n]
+        result = OBV(close, volume)
+        assert np.all(np.isfinite(result))
+
+
+@pytest.mark.skipif(not HAS_HYPOTHESIS, reason="hypothesis not installed")
+class TestPropertyBased:
+    """Placeholder for running property-based tests as a class."""
+
+    def test_import(self):
+        assert HAS_HYPOTHESIS

ferro-ta-main/tests/unit/test_validation.py

@@ -0,0 +1,155 @@
+"""Tests for validation and error handling."""
+
+import numpy as np
+import pytest
+
+from ferro_ta import (
+    ATR,
+    BBANDS,
+    CDLDOJI,
+    MACD,
+    RSI,
+    SMA,
+    FerroTAInputError,
+    FerroTAValueError,
+)
+from ferro_ta.core.exceptions import check_min_length, check_timeperiod
+
+# ---------------------------------------------------------------------------
+# Invalid timeperiod / period parameters → FerroTAValueError
+# ---------------------------------------------------------------------------
+
+
+class TestInvalidTimeperiod:
+    """Invalid period parameters must raise FerroTAValueError."""
+
+    def test_sma_timeperiod_zero(self):
+        with pytest.raises(FerroTAValueError, match="timeperiod must be >= 1"):
+            SMA(np.array([1.0, 2.0, 3.0]), timeperiod=0)
+
+    def test_sma_timeperiod_negative(self):
+        with pytest.raises(FerroTAValueError, match="timeperiod must be >= 1"):
+            SMA(np.array([1.0, 2.0, 3.0]), timeperiod=-1)
+
+    def test_rsi_timeperiod_zero(self):
+        with pytest.raises(FerroTAValueError, match="timeperiod must be >= 1"):
+            RSI(np.array([1.0, 2.0, 3.0]), timeperiod=0)
+
+    def test_macd_fast_slow_periods(self):
+        close = np.array([1.0, 2.0, 3.0, 4.0, 5.0] * 10)
+        with pytest.raises(FerroTAValueError):
+            MACD(close, fastperiod=26, slowperiod=12)
+
+    def test_bbands_timeperiod_zero(self):
+        with pytest.raises(FerroTAValueError, match="timeperiod must be >= 1"):
+            BBANDS(np.array([1.0, 2.0, 3.0]), timeperiod=0)
+
+    def test_atr_timeperiod_zero(self):
+        h = np.array([1.0, 2.0, 3.0])
+        low = np.array([0.5, 1.5, 2.5])
+        c = np.array([0.8, 1.8, 2.8])
+        with pytest.raises(FerroTAValueError, match="timeperiod must be >= 1"):
+            ATR(h, low, c, timeperiod=0)
+
+
+# ---------------------------------------------------------------------------
+# Mismatched array lengths → FerroTAInputError
+# ---------------------------------------------------------------------------
+
+
+class TestMismatchedLengths:
+    """Mismatched OHLCV lengths must raise FerroTAInputError."""
+
+    def test_atr_mismatched_lengths(self):
+        h = np.array([1.0, 2.0, 3.0])
+        low = np.array([0.5, 1.5])
+        c = np.array([0.8, 1.8, 2.8])
+        with pytest.raises(FerroTAInputError, match="same length"):
+            ATR(h, low, c, timeperiod=2)
+
+    def test_cdl_pattern_mismatched_lengths(self):
+        open_ = np.array([1.0, 2.0, 3.0])
+        high = np.array([1.1, 2.1])
+        low = np.array([0.9, 1.9, 2.9])
+        close = np.array([1.05, 2.05, 3.05])
+        with pytest.raises(FerroTAInputError, match="same length"):
+            CDLDOJI(open_, high, low, close)
+
+
+# ---------------------------------------------------------------------------
+# Empty and short arrays (defined behaviour or clear exception)
+# ---------------------------------------------------------------------------
+
+
+class TestEmptyAndShortArrays:
+    """Empty or too-short arrays have defined behaviour or raise."""
+
+    def test_sma_empty_array(self):
+        # Empty array: _to_f64 returns shape (0,); Rust may return empty or raise.
+        arr = np.array([], dtype=np.float64)
+        result = SMA(arr, timeperiod=1)
+        assert result.shape == (0,)
+
+    def test_sma_single_element_timeperiod_one(self):
+        arr = np.array([1.0])
+        result = SMA(arr, timeperiod=1)
+        assert len(result) == 1
+        assert result[0] == 1.0
+
+    def test_sma_short_array_timeperiod_larger_than_length(self):
+        # len=3, timeperiod=5 → output is all NaN for warmup
+        arr = np.array([1.0, 2.0, 3.0])
+        result = SMA(arr, timeperiod=5)
+        assert len(result) == 3
+        assert np.all(np.isnan(result))
+
+    def test_rsi_all_nan_input(self):
+        # All-NaN input: output is all NaN (propagation)
+        arr = np.array([np.nan, np.nan, np.nan, np.nan, np.nan])
+        result = RSI(arr, timeperiod=2)
+        assert len(result) == 5
+        assert np.all(np.isnan(result))
+
+
+# ---------------------------------------------------------------------------
+# Validation helpers (check_timeperiod, check_min_length)
+# ---------------------------------------------------------------------------
+
+
+class TestValidationHelpers:
+    """Exported validation helpers behave as documented."""
+
+    def test_check_timeperiod_ok(self):
+        check_timeperiod(5)
+        check_timeperiod(1)
+
+    def test_check_timeperiod_raises(self):
+        with pytest.raises(FerroTAValueError, match="timeperiod must be >= 1"):
+            check_timeperiod(0)
+        with pytest.raises(FerroTAValueError, match="timeperiod must be >= 1"):
+            check_timeperiod(-1)
+
+    def test_check_min_length_ok(self):
+        check_min_length(np.array([1.0, 2.0, 3.0]), 2)
+        check_min_length([1, 2, 3], 3)
+
+    def test_check_min_length_raises(self):
+        with pytest.raises(FerroTAInputError, match="at least 3 elements"):
+            check_min_length(np.array([1.0, 2.0]), 3, name="input")
+
+
+# ---------------------------------------------------------------------------
+# Exception inheritance (ValueError still works)
+# ---------------------------------------------------------------------------
+
+
+class TestExceptionInheritance:
+    """FerroTAValueError/FerroTAInputError are ValueErrors for backward compatibility."""
+
+    def test_catch_value_error(self):
+        with pytest.raises(ValueError, match="timeperiod must be >= 1"):
+            SMA(np.array([1.0, 2.0, 3.0]), timeperiod=0)
+
+    def test_catch_ferro_ta_value_error(self):
+        with pytest.raises(FerroTAValueError):
+            SMA(np.array([1.0, 2.0, 3.0]), timeperiod=0)