mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-07-27 17:27:43 +00:00
Miha Kralj
33d20f2a18
Complete thin Dx-composition wrapper indicators with full test coverage: - PlusDi/MinusDi: Directional Indicator wrappers (DiPlus/DiMinus from Dx) - PlusDm/MinusDm: Directional Movement wrappers (DmPlus/DmMinus from Dx) - Individual validation tests per indicator directory (TALib, Skender, bounds) - Combined unit tests (DiDm.Tests.cs) and validation tests (DiDm.Validation.Tests.cs) - Quantower wrappers + tests for all 4 indicators - PineScript v6 implementations with compensated RMA - Normalized .md documentation for all indicators and categories - 182 tests passing, 0 failures
819 lines
27 KiB
C#
819 lines
27 KiB
C#
using OoplesFinance.StockIndicators;
|
|
using OoplesFinance.StockIndicators.Models;
|
|
using OoplesFinance.StockIndicators.Enums;
|
|
using Skender.Stock.Indicators;
|
|
using TALib;
|
|
using QuanTAlib.Tests;
|
|
|
|
namespace QuanTAlib;
|
|
|
|
/// <summary>
|
|
/// Combined validation tests for PlusDi, MinusDi, PlusDm, MinusDm.
|
|
/// Cross-validates against TA-Lib, Skender, Ooples, and Dx equivalence.
|
|
/// </summary>
|
|
public sealed class DiDmValidationTests : IDisposable
|
|
{
|
|
private readonly ValidationTestData _data;
|
|
|
|
public DiDmValidationTests()
|
|
{
|
|
_data = new ValidationTestData();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_data.Dispose();
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// TA-Lib Validation
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_MatchesTalib()
|
|
{
|
|
var indicator = new PlusDi(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.PlusDI(hData, lData, cData, 0..^0, outReal, out var outRange, 14);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.PlusDILookback(14);
|
|
ValidationHelper.VerifyData(results, outReal, outRange, lookback);
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_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);
|
|
}
|
|
|
|
[Fact]
|
|
public void PlusDm_MatchesTalib()
|
|
{
|
|
var indicator = new PlusDm(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[] outReal = new double[_data.Bars.Count];
|
|
|
|
var retCode = Functions.PlusDM(hData, lData, 0..^0, outReal, out var outRange, 14);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.PlusDMLookback(14);
|
|
ValidationHelper.VerifyData(results, outReal, outRange, lookback);
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDm_MatchesTalib()
|
|
{
|
|
var indicator = new MinusDm(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[] outReal = new double[_data.Bars.Count];
|
|
|
|
var retCode = Functions.MinusDM(hData, lData, 0..^0, outReal, out var outRange, 14);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.MinusDMLookback(14);
|
|
ValidationHelper.VerifyData(results, outReal, outRange, lookback);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Skender Validation
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_MatchesSkender()
|
|
{
|
|
var indicator = new PlusDi(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.Pdi);
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_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);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Dx Equivalence
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_ExactlyMatchesDx_DiPlus()
|
|
{
|
|
var indicator = new PlusDi(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.DiPlus.Value, indicator.Last.Value, 1e-12);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_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);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void PlusDm_ExactlyMatchesDx_DmPlus()
|
|
{
|
|
var indicator = new PlusDm(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.DmPlus.Value, indicator.Last.Value, 1e-12);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDm_ExactlyMatchesDx_DmMinus()
|
|
{
|
|
var indicator = new MinusDm(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.DmMinus.Value, indicator.Last.Value, 1e-12);
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Self-Consistency: Batch == Streaming
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_BatchEqualsStreaming()
|
|
{
|
|
var batchResults = PlusDi.Batch(_data.Bars, 14);
|
|
|
|
var streaming = new PlusDi(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 MinusDi_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 PlusDm_BatchEqualsStreaming()
|
|
{
|
|
var batchResults = PlusDm.Batch(_data.Bars, 14);
|
|
|
|
var streaming = new PlusDm(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 MinusDm_BatchEqualsStreaming()
|
|
{
|
|
var batchResults = MinusDm.Batch(_data.Bars, 14);
|
|
|
|
var streaming = new MinusDm(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);
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Multi-Period TALib Validation
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Theory]
|
|
[InlineData(7)]
|
|
[InlineData(21)]
|
|
[InlineData(28)]
|
|
public void PlusDi_MatchesTalib_VariousPeriods(int period)
|
|
{
|
|
var indicator = new PlusDi(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.PlusDI(hData, lData, cData, 0..^0, outReal, out var outRange, period);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.PlusDILookback(period);
|
|
ValidationHelper.VerifyData(results, outReal, outRange, lookback);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(7)]
|
|
[InlineData(21)]
|
|
[InlineData(28)]
|
|
public void MinusDi_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);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(7)]
|
|
[InlineData(21)]
|
|
[InlineData(28)]
|
|
public void PlusDm_MatchesTalib_VariousPeriods(int period)
|
|
{
|
|
var indicator = new PlusDm(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[] outReal = new double[_data.Bars.Count];
|
|
|
|
var retCode = Functions.PlusDM(hData, lData, 0..^0, outReal, out var outRange, period);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.PlusDMLookback(period);
|
|
ValidationHelper.VerifyData(results, outReal, outRange, lookback);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(7)]
|
|
[InlineData(21)]
|
|
[InlineData(28)]
|
|
public void MinusDm_MatchesTalib_VariousPeriods(int period)
|
|
{
|
|
var indicator = new MinusDm(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[] outReal = new double[_data.Bars.Count];
|
|
|
|
var retCode = Functions.MinusDM(hData, lData, 0..^0, outReal, out var outRange, period);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.MinusDMLookback(period);
|
|
ValidationHelper.VerifyData(results, outReal, outRange, lookback);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Multi-Period Skender Validation
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Theory]
|
|
[InlineData(7)]
|
|
[InlineData(21)]
|
|
[InlineData(28)]
|
|
public void PlusDi_MatchesSkender_VariousPeriods(int period)
|
|
{
|
|
var indicator = new PlusDi(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.Pdi);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(7)]
|
|
[InlineData(21)]
|
|
[InlineData(28)]
|
|
public void MinusDi_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);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Determinism: Consistent Across Multiple Runs
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_ConsistentAcrossMultipleRuns()
|
|
{
|
|
var ind1 = new PlusDi(14);
|
|
var ind2 = new PlusDi(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);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_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);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void PlusDm_ConsistentAcrossMultipleRuns()
|
|
{
|
|
var ind1 = new PlusDm(14);
|
|
var ind2 = new PlusDm(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);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDm_ConsistentAcrossMultipleRuns()
|
|
{
|
|
var ind1 = new MinusDm(14);
|
|
var ind2 = new MinusDm(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);
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Non-Negative Output Validation
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_OutputIsNonNegative()
|
|
{
|
|
var indicator = new PlusDi(14);
|
|
|
|
for (int i = 0; i < _data.Bars.Count; i++)
|
|
{
|
|
indicator.Update(_data.Bars[i]);
|
|
Assert.True(indicator.Last.Value >= 0, $"PlusDi output at bar {i} was {indicator.Last.Value}");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_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, $"MinusDi output at bar {i} was {indicator.Last.Value}");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void PlusDm_OutputIsNonNegative()
|
|
{
|
|
var indicator = new PlusDm(14);
|
|
|
|
for (int i = 0; i < _data.Bars.Count; i++)
|
|
{
|
|
indicator.Update(_data.Bars[i]);
|
|
Assert.True(indicator.Last.Value >= 0, $"PlusDm output at bar {i} was {indicator.Last.Value}");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDm_OutputIsNonNegative()
|
|
{
|
|
var indicator = new MinusDm(14);
|
|
|
|
for (int i = 0; i < _data.Bars.Count; i++)
|
|
{
|
|
indicator.Update(_data.Bars[i]);
|
|
Assert.True(indicator.Last.Value >= 0, $"MinusDm output at bar {i} was {indicator.Last.Value}");
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// DI values bounded 0-100
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_OutputBounded0To100()
|
|
{
|
|
var indicator = new PlusDi(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, $"PlusDi at bar {i} was {val}, expected [0,100]");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_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, $"MinusDi at bar {i} was {val}, expected [0,100]");
|
|
}
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Different Periods Produce Different Results
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_DifferentPeriods_ProduceDifferentResults()
|
|
{
|
|
var short14 = new PlusDi(7);
|
|
var long28 = new PlusDi(28);
|
|
|
|
for (int i = 0; i < _data.Bars.Count; i++)
|
|
{
|
|
short14.Update(_data.Bars[i]);
|
|
long28.Update(_data.Bars[i]);
|
|
}
|
|
|
|
Assert.NotEqual(short14.Last.Value, long28.Last.Value);
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_DifferentPeriods_ProduceDifferentResults()
|
|
{
|
|
var short14 = new MinusDi(7);
|
|
var long28 = new MinusDi(28);
|
|
|
|
for (int i = 0; i < _data.Bars.Count; i++)
|
|
{
|
|
short14.Update(_data.Bars[i]);
|
|
long28.Update(_data.Bars[i]);
|
|
}
|
|
|
|
Assert.NotEqual(short14.Last.Value, long28.Last.Value);
|
|
}
|
|
|
|
[Fact]
|
|
public void PlusDm_DifferentPeriods_ProduceDifferentResults()
|
|
{
|
|
var short14 = new PlusDm(7);
|
|
var long28 = new PlusDm(28);
|
|
|
|
for (int i = 0; i < _data.Bars.Count; i++)
|
|
{
|
|
short14.Update(_data.Bars[i]);
|
|
long28.Update(_data.Bars[i]);
|
|
}
|
|
|
|
Assert.NotEqual(short14.Last.Value, long28.Last.Value);
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDm_DifferentPeriods_ProduceDifferentResults()
|
|
{
|
|
var short14 = new MinusDm(7);
|
|
var long28 = new MinusDm(28);
|
|
|
|
for (int i = 0; i < _data.Bars.Count; i++)
|
|
{
|
|
short14.Update(_data.Bars[i]);
|
|
long28.Update(_data.Bars[i]);
|
|
}
|
|
|
|
Assert.NotEqual(short14.Last.Value, long28.Last.Value);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// OoplesFinance Structural Validation
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void DiDm_MatchesOoples_Structural()
|
|
{
|
|
// OoplesFinance.CalculateAverageDirectionalIndex produces Di+/Di- as part of ADX
|
|
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);
|
|
|
|
// Verify the Ooples ADX calculation produces finite DI values
|
|
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/DM values, got {finiteCount}");
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════
|
|
// Batch Matches TALib
|
|
// ═══════════════════════════════════════════════
|
|
|
|
[Fact]
|
|
public void PlusDi_BatchMatchesTalib()
|
|
{
|
|
var batchResults = PlusDi.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.PlusDI(hData, lData, cData, 0..^0, outReal, out var outRange, 14);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.PlusDILookback(14);
|
|
ValidationHelper.VerifyData(batchResults.Select(x => x.Value).ToList(), outReal, outRange, lookback);
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDi_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);
|
|
}
|
|
|
|
[Fact]
|
|
public void PlusDm_BatchMatchesTalib()
|
|
{
|
|
var batchResults = PlusDm.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[] outReal = new double[_data.Bars.Count];
|
|
|
|
var retCode = Functions.PlusDM(hData, lData, 0..^0, outReal, out var outRange, 14);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.PlusDMLookback(14);
|
|
ValidationHelper.VerifyData(batchResults.Select(x => x.Value).ToList(), outReal, outRange, lookback);
|
|
}
|
|
|
|
[Fact]
|
|
public void MinusDm_BatchMatchesTalib()
|
|
{
|
|
var batchResults = MinusDm.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[] outReal = new double[_data.Bars.Count];
|
|
|
|
var retCode = Functions.MinusDM(hData, lData, 0..^0, outReal, out var outRange, 14);
|
|
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
|
|
|
int lookback = Functions.MinusDMLookback(14);
|
|
ValidationHelper.VerifyData(batchResults.Select(x => x.Value).ToList(), outReal, outRange, lookback);
|
|
}
|
|
}
|