QuanTAlib/lib/reversals/sar/tests/Sar.Validation.Tests.cs

// SAR Validation Tests - Parabolic Stop And Reverse
// Cross-validated against Skender.Stock.Indicators GetParabolicSar(), TALib SAR, and OoplesFinance CalculateParabolicSAR.

using OoplesFinance.StockIndicators;
using OoplesFinance.StockIndicators.Models;
using Skender.Stock.Indicators;
using TALib;

namespace QuanTAlib.Tests;

public sealed class SarValidationTests
{
    private static TBarSeries CreateGbmBars(int count = 500, int seed = 42)
    {
        var gbm = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.20, seed: seed);
        return gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
    }

    // ── Cross-library: Skender ───────────────────────────────────────────

    [Fact]
    public void StreamingMatchesSkender()
    {
        var _data = new ValidationTestData();

        // Skender: GetParabolicSar(accelerationStep, maxAccelerationFactor, initialFactor)
        var skenderResults = _data.SkenderQuotes
            .GetParabolicSar(0.02, 0.2, 0.02)
            .ToList();

        // QuanTAlib streaming
        var sar = new Sar(afStart: 0.02, afIncrement: 0.02, afMax: 0.20);
        var ourValues = new double[_data.Bars.Count];
        for (int i = 0; i < _data.Bars.Count; i++)
        {
            _ = sar.Update(_data.Bars[i], isNew: true);
            ourValues[i] = sar.SarValue;
        }

        // Compare warm values (skip first bar where SAR is initialization)
        int matched = 0;
        for (int i = 2; i < skenderResults.Count && i < _data.Bars.Count; i++)
        {
            if (skenderResults[i].Sar.HasValue && double.IsFinite(ourValues[i]))
            {
                Assert.Equal(
                    skenderResults[i].Sar!.Value,
                    ourValues[i],
                    precision: 6);
                matched++;
            }
        }

        Assert.True(matched > 0, "Should have matched at least one warm value");
        _data.Dispose();
    }

    // ── Self-Consistency: Streaming == Batch ──────────────────────────────

    [Fact]
    public void StreamingMatchesBatch()
    {
        var bars = CreateGbmBars();

        // Streaming
        var streaming = new Sar();
        var streamValues = new double[bars.Count];
        for (int i = 0; i < bars.Count; i++)
        {
            _ = streaming.Update(bars[i], isNew: true);
            streamValues[i] = streaming.SarValue;
        }

        // Batch
        var batchResults = Sar.Batch(bars);

        for (int i = 0; i < bars.Count; i++)
        {
            Assert.Equal(streamValues[i], batchResults[i].Value, precision: 10);
        }
    }

    // ── Self-Consistency: Streaming == Span ───────────────────────────────

    [Fact]
    public void StreamingMatchesSpan()
    {
        var bars = CreateGbmBars();

        // Streaming
        var streaming = new Sar();
        var streamValues = new double[bars.Count];
        for (int i = 0; i < bars.Count; i++)
        {
            _ = streaming.Update(bars[i], isNew: true);
            streamValues[i] = streaming.SarValue;
        }

        // Span
        var spanOutput = new double[bars.Count];
        Sar.Batch(bars.OpenValues, bars.HighValues, bars.LowValues, bars.CloseValues, spanOutput);

        for (int i = 0; i < bars.Count; i++)
        {
            Assert.Equal(streamValues[i], spanOutput[i], precision: 10);
        }
    }

    // ── AF Sensitivity ───────────────────────────────────────────────────

    [Fact]
    public void HigherAfStart_TighterTrailingStop()
    {
        var bars = CreateGbmBars(count: 100);

        var slow = new Sar(afStart: 0.01, afIncrement: 0.01, afMax: 0.20);
        var fast = new Sar(afStart: 0.10, afIncrement: 0.05, afMax: 0.50);

        for (int i = 0; i < bars.Count; i++)
        {
            _ = slow.Update(bars[i], isNew: true);
            _ = fast.Update(bars[i], isNew: true);
        }

        // Higher AF = more responsive = SAR closer to price
        // Just verify both produce finite output (direction depends on data)
        Assert.True(double.IsFinite(slow.SarValue));
        Assert.True(double.IsFinite(fast.SarValue));
    }

    // ── Determinism ──────────────────────────────────────────────────────

    [Fact]
    public void SameInput_ProducesSameOutput()
    {
        var bars = CreateGbmBars(count: 200, seed: 123);

        var psar1 = new Sar();
        var psar2 = new Sar();

        for (int i = 0; i < bars.Count; i++)
        {
            _ = psar1.Update(bars[i], isNew: true);
            _ = psar2.Update(bars[i], isNew: true);
        }

        Assert.Equal(psar1.SarValue, psar2.SarValue);
    }

    // ── Calculate Returns Valid Indicator ─────────────────────────────────

    [Fact]
    public void Calculate_ReturnsValidIndicatorAndResults()
    {
        var bars = CreateGbmBars(count: 100);

        var (results, indicator) = Sar.Calculate(bars);

        Assert.NotNull(results);
        Assert.Equal(bars.Count, results.Count);
        Assert.True(indicator.IsHot);
        Assert.True(double.IsFinite(indicator.SarValue));
    }

    // ── Reversal Count Is Reasonable ─────────────────────────────────────

    [Fact]
    public void ReversalCount_IsReasonable()
    {
        var bars = CreateGbmBars(count: 500);
        var sar = new Sar();

        int reversals = 0;
        bool prevIsLong = true;

        for (int i = 0; i < bars.Count; i++)
        {
            _ = sar.Update(bars[i], isNew: true);

            if (i > 0 && sar.IsLong != prevIsLong)
            {
                reversals++;
            }
            prevIsLong = sar.IsLong;
        }

        // In 500 bars of GBM data, expect several reversals but not every bar
        Assert.True(reversals > 5, $"Expected > 5 reversals, got {reversals}");
        Assert.True(reversals < 250, $"Expected < 250 reversals, got {reversals}");
    }

    [Fact]
    public void StreamingMatchesTalib()
    {
        /* TALib SAR uses the same Wilder parabolic SAR formula as QuanTAlib.
           Parameters: accelerationFactor=0.02 (step), maximum=0.20 (cap).
           Initialization differences produce a short divergence; values converge after first reversal.
           We accept up to 2% mismatch for edge-of-reversal rounding at period boundaries. */

        var _data = new ValidationTestData();

        double[] highData = _data.Bars.High.Values.ToArray();
        double[] lowData = _data.Bars.Low.Values.ToArray();
        double[] taOut = new double[_data.Bars.Count];

        const double afStep = 0.02;
        const double afMax = 0.20;

        var retCode = Functions.Sar<double>(
            highData, lowData,
            0..^0, taOut, out var outRange,
            afStep, afMax);
        Assert.Equal(TALib.Core.RetCode.Success, retCode);

        (int offset, int length) = outRange.GetOffsetAndLength(taOut.Length);
        Assert.True(length > 100, $"TALib SAR produced only {length} values");

        // QuanTAlib streaming
        var sar = new Sar(afStart: afStep, afIncrement: afStep, afMax: afMax);
        var qlSar = new double[_data.Bars.Count];
        for (int i = 0; i < _data.Bars.Count; i++)
        {
            _ = sar.Update(_data.Bars[i], isNew: true);
            qlSar[i] = sar.SarValue;
        }

        // Skip the first ~5 bars (initialization divergence), then require exact match.
        int skipBars = 5;
        int compared = 0;
        int matched = 0;
        for (int j = skipBars; j < length; j++)
        {
            int qi = j + offset;
            if (!double.IsFinite(qlSar[qi]) || !double.IsFinite(taOut[j])) { continue; }
            compared++;
            double diff = Math.Abs(qlSar[qi] - taOut[j]);
            if (diff <= 1e-9) { matched++; }
        }

        // After initialization, QuanTAlib and TALib SAR should converge fully.
        // Accept up to 2% mismatch for edge-of-reversal rounding at period boundaries.
        double matchRate = compared > 0 ? (double)matched / compared : 0;
        Assert.True(matchRate >= 0.98,
            $"TALib SAR match rate {matchRate:P1} ({matched}/{compared}) < 98% — unexpected divergence");

        _data.Dispose();
    }

    // ── Cross-library: OoplesFinance ────────────────────────────────────

    /// <summary>
    /// Structural validation against Ooples <c>CalculateParabolicSAR</c>.
    /// Ooples SAR uses the same Wilder acceleration factor algorithm (start=0.02, increment=0.02, max=0.2).
    /// Cross-library numeric equality is not asserted because reversal-point initialization
    /// diverges across implementations when the very first bar direction is ambiguous.
    /// Both must produce finite, positive output on the same OHLCV data.
    /// </summary>
    [Fact]
    public void Sar_MatchesOoples_Structural()
    {
        var _data = new ValidationTestData();

        var ooplesData = _data.SkenderQuotes.Select(q => new TickerData
        {
            Date = q.Date,
            Open = (double)q.Open,
            High = (double)q.High,
            Low = (double)q.Low,
            Close = (double)q.Close,
            Volume = (double)q.Volume
        }).ToList();

        var stockData = new StockData(ooplesData);
        var oResult = stockData.CalculateParabolicSAR(start: 0.02, increment: 0.02, maximum: 0.2);
        var oValues = oResult.OutputValues.Values.First();

        var sar = new Sar(afStart: 0.02, afIncrement: 0.02, afMax: 0.20);
        var qValues = new System.Collections.Generic.List<double>();
        foreach (var bar in _data.Data)
        {
            qValues.Add(sar.Update(bar).Value);
        }

        Assert.True(oValues.Count > 0, "Ooples SAR must produce output");

        int finiteCount = 0;
        int warmup = 5;
        for (int i = warmup; i < Math.Min(oValues.Count, qValues.Count); i++)
        {
            if (double.IsFinite(oValues[i]) && double.IsFinite(qValues[i]) && qValues[i] > 0)
            {
                finiteCount++;
            }
        }

        Assert.True(finiteCount > 100, $"Expected >100 finite positive SAR pairs, got {finiteCount}");

        _data.Dispose();
    }
}