docs: remove C# Implementation Considerations sections, clean up temp scripts, reorganize test files

- Remove 'C# Implementation Considerations' sections from 34 indicator .md files - Delete 29 temp PowerShell scripts (_fix_mojibake.ps1, _hex_scan.ps1, etc.) - Move test files into tests/ subdirectories for consistent project structure - Add trader-focused bullet points to indicator documentation
2026-08-23 21:18:04 +00:00 · 2026-03-12 12:34:16 -07:00
parent 8937b0c0fa
commit 060649192f
1149 changed files with 1780 additions and 3316 deletions
@@ -0,0 +1,73 @@
+using TradingPlatform.BusinessLayer;
+using QuanTAlib;
+
+namespace QuanTAlib.Tests;
+
+public class MinusDiIndicatorTests
+{
+    [Fact]
+    public void MinusDiIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new MinusDiIndicator();
+
+        Assert.Equal(14, indicator.Period);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("-DI - Minus Directional Indicator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void MinusDiIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new MinusDiIndicator { Period = 20 };
+
+        Assert.Equal(0, MinusDiIndicator.MinHistoryDepths);
+        IWatchlistIndicator watchlistIndicator = indicator;
+        Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void MinusDiIndicator_Initialize_CreatesInternal()
+    {
+        var indicator = new MinusDiIndicator { Period = 14 };
+
+        indicator.Initialize();
+
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void MinusDiIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new MinusDiIndicator { Period = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void MinusDiIndicator_ShortName_IsCorrect()
+    {
+        var indicator = new MinusDiIndicator { Period = 20 };
+        Assert.Equal("-DI 20", indicator.ShortName);
+    }
+
+    [Fact]
+    public void MinusDiIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new MinusDiIndicator();
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("MinusDi.Quantower.cs", indicator.SourceCodeLink, StringComparison.OrdinalIgnoreCase);
+    }
+}
@@ -0,0 +1,288 @@
+using OoplesFinance.StockIndicators;
+using OoplesFinance.StockIndicators.Models;
+using OoplesFinance.StockIndicators.Enums;
+using Skender.Stock.Indicators;
+using TALib;
+using QuanTAlib.Tests;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// Validation tests for MinusDi (-DI). Cross-validates against TA-Lib, Skender,
+/// OoplesFinance, and internal Dx equivalence with multiple periods.
+/// </summary>
+public sealed class MinusDiValidationTests : IDisposable
+{
+    private readonly ValidationTestData _data;
+
+    public MinusDiValidationTests()
+    {
+        _data = new ValidationTestData();
+    }
+
+    public void Dispose()
+    {
+        _data.Dispose();
+    }
+
+    // ═══════════════════════════════════════════════
+    //  TA-Lib Validation
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void MatchesTalib()
+    {
+        var indicator = new MinusDi(14);
+        var results = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            indicator.Update(_data.Bars[i]);
+            results.Add(indicator.Last.Value);
+        }
+
+        double[] hData = _data.Bars.High.Select(x => x.Value).ToArray();
+        double[] lData = _data.Bars.Low.Select(x => x.Value).ToArray();
+        double[] cData = _data.Bars.Close.Select(x => x.Value).ToArray();
+        double[] outReal = new double[_data.Bars.Count];
+
+        var retCode = Functions.MinusDI(hData, lData, cData, 0..^0, outReal, out var outRange, 14);
+        Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+        int lookback = Functions.MinusDILookback(14);
+        ValidationHelper.VerifyData(results, outReal, outRange, lookback);
+    }
+
+    [Theory]
+    [InlineData(7)]
+    [InlineData(21)]
+    [InlineData(28)]
+    public void MatchesTalib_VariousPeriods(int period)
+    {
+        var indicator = new MinusDi(period);
+        var results = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            indicator.Update(_data.Bars[i]);
+            results.Add(indicator.Last.Value);
+        }
+
+        double[] hData = _data.Bars.High.Select(x => x.Value).ToArray();
+        double[] lData = _data.Bars.Low.Select(x => x.Value).ToArray();
+        double[] cData = _data.Bars.Close.Select(x => x.Value).ToArray();
+        double[] outReal = new double[_data.Bars.Count];
+
+        var retCode = Functions.MinusDI(hData, lData, cData, 0..^0, outReal, out var outRange, period);
+        Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+        int lookback = Functions.MinusDILookback(period);
+        ValidationHelper.VerifyData(results, outReal, outRange, lookback);
+    }
+
+    // ═══════════════════════════════════════════════
+    //  Skender Validation
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void MatchesSkender()
+    {
+        var indicator = new MinusDi(14);
+        var results = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            indicator.Update(_data.Bars[i]);
+            results.Add(indicator.Last.Value);
+        }
+
+        var skenderResults = _data.SkenderQuotes.GetAdx(14).ToList();
+        ValidationHelper.VerifyData(results, skenderResults, x => x.Mdi);
+    }
+
+    [Theory]
+    [InlineData(7)]
+    [InlineData(21)]
+    [InlineData(28)]
+    public void MatchesSkender_VariousPeriods(int period)
+    {
+        var indicator = new MinusDi(period);
+        var results = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            indicator.Update(_data.Bars[i]);
+            results.Add(indicator.Last.Value);
+        }
+
+        var skenderResults = _data.SkenderQuotes.GetAdx(period).ToList();
+        ValidationHelper.VerifyData(results, skenderResults, x => x.Mdi);
+    }
+
+    // ═══════════════════════════════════════════════
+    //  Dx Equivalence
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void ExactlyMatchesDx_DiMinus()
+    {
+        var indicator = new MinusDi(14);
+        var dx = new Dx(14);
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            indicator.Update(_data.Bars[i]);
+            dx.Update(_data.Bars[i]);
+
+            Assert.Equal(dx.DiMinus.Value, indicator.Last.Value, 1e-12);
+        }
+    }
+
+    // ═══════════════════════════════════════════════
+    //  OoplesFinance Structural Validation
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void MatchesOoples_Structural()
+    {
+        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 adxResults = stockData.CalculateAverageDirectionalIndex(MovingAvgType.WildersSmoothingMethod, 14);
+
+        var allValues = adxResults.OutputValues.Values.SelectMany(v => v).ToList();
+        int finiteCount = allValues.Count(v => double.IsFinite(v));
+        Assert.True(finiteCount > 100, $"Expected >100 finite Ooples DI values, got {finiteCount}");
+    }
+
+    // ═══════════════════════════════════════════════
+    //  Self-Consistency: Batch == Streaming
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void BatchEqualsStreaming()
+    {
+        var batchResults = MinusDi.Batch(_data.Bars, 14);
+
+        var streaming = new MinusDi(14);
+        var streamResults = new List<double>();
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            streamResults.Add(streaming.Update(_data.Bars[i]).Value);
+        }
+
+        Assert.Equal(streamResults.Count, batchResults.Count);
+        for (int i = 0; i < batchResults.Count; i++)
+        {
+            Assert.Equal(streamResults[i], batchResults.Values[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void BatchMatchesTalib()
+    {
+        var batchResults = MinusDi.Batch(_data.Bars, 14);
+
+        double[] hData = _data.Bars.High.Select(x => x.Value).ToArray();
+        double[] lData = _data.Bars.Low.Select(x => x.Value).ToArray();
+        double[] cData = _data.Bars.Close.Select(x => x.Value).ToArray();
+        double[] outReal = new double[_data.Bars.Count];
+
+        var retCode = Functions.MinusDI(hData, lData, cData, 0..^0, outReal, out var outRange, 14);
+        Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+        int lookback = Functions.MinusDILookback(14);
+        ValidationHelper.VerifyData(batchResults.Select(x => x.Value).ToList(), outReal, outRange, lookback);
+    }
+
+    // ═══════════════════════════════════════════════
+    //  Determinism
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void ConsistentAcrossMultipleRuns()
+    {
+        var ind1 = new MinusDi(14);
+        var ind2 = new MinusDi(14);
+        var results1 = new List<double>();
+        var results2 = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            ind1.Update(_data.Bars[i]);
+            results1.Add(ind1.Last.Value);
+        }
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            ind2.Update(_data.Bars[i]);
+            results2.Add(ind2.Last.Value);
+        }
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            Assert.Equal(results1[i], results2[i], 1e-10);
+        }
+    }
+
+    // ═══════════════════════════════════════════════
+    //  Output Range Validation
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void OutputIsNonNegative()
+    {
+        var indicator = new MinusDi(14);
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            indicator.Update(_data.Bars[i]);
+            Assert.True(indicator.Last.Value >= 0, $"-DI output at bar {i} was {indicator.Last.Value}");
+        }
+    }
+
+    [Fact]
+    public void OutputBounded0To100()
+    {
+        var indicator = new MinusDi(14);
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            indicator.Update(_data.Bars[i]);
+            double val = indicator.Last.Value;
+            if (i >= 14)
+            {
+                Assert.True(val >= 0 && val <= 100, $"-DI at bar {i} was {val}, expected [0,100]");
+            }
+        }
+    }
+
+    // ═══════════════════════════════════════════════
+    //  Different Periods Produce Different Results
+    // ═══════════════════════════════════════════════
+
+    [Fact]
+    public void DifferentPeriods_ProduceDifferentResults()
+    {
+        var short7 = new MinusDi(7);
+        var long28 = new MinusDi(28);
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            short7.Update(_data.Bars[i]);
+            long28.Update(_data.Bars[i]);
+        }
+
+        Assert.NotEqual(short7.Last.Value, long28.Last.Value);
+    }
+}