gavindiaz/QuanTAlib
1
0
Fork 0
mirror of https://github.com/mihakralj/QuanTAlib.git synced 2026-08-24 13:38:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor validation tests for various indicators to utilize shared test data structure

Browse Source
This commit is contained in:
Miha Kralj
2025-12-12 13:47:57 -08:00
parent e6033638ad
commit cea3e0c46d
29 changed files with 1167 additions and 1804 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/trends/wma/Wma.Validation.Tests.cs
+64 -245
View File
@@ -1,45 +1,25 @@
using System;
using System.Collections.Generic;
using System.Linq;
using OoplesFinance.StockIndicators;
using OoplesFinance.StockIndicators.Models;
using Skender.Stock.Indicators;
using TALib;
using Tulip;
using Xunit;
using Xunit.Abstractions;
namespace QuanTAlib.Tests;
public class WmaValidationTests
{
private readonly TBarSeries _bars;
private readonly TSeries _data;
private readonly List<Quote> _skenderQuotes;
private readonly ValidationTestData _testData;
private readonly ITestOutputHelper _output;
public WmaValidationTests(ITestOutputHelper output)
{
_output = output;
// 1. Generate 5000 records using GBM feed
var gbm = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.2);
_bars = gbm.Fetch(5000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
// 2. Extract Close TSeries
_data = _bars.Close;
// 3. Prepare data for Skender (List<Quote>)
_skenderQuotes = new List<Quote>();
for (int i = 0; i < _bars.Count; i++)
{
_skenderQuotes.Add(new Quote
{
Date = new DateTime(_bars.Open.Times[i], DateTimeKind.Utc),
Open = (decimal)_bars.Open[i].Value,
High = (decimal)_bars.High[i].Value,
Low = (decimal)_bars.Low[i].Value,
Close = (decimal)_bars.Close[i].Value,
Volume = (decimal)_bars.Volume[i].Value
});
}
_testData = new ValidationTestData();
}
[Fact]
@@ -51,13 +31,13 @@ public class WmaValidationTests
{
// Calculate QuanTAlib WMA (batch TSeries)
var wma = new global::QuanTAlib.Wma(period);
var qResult = wma.Update(_data);
var qResult = wma.Update(_testData.Data);
// Calculate Skender WMA
var sResult = _skenderQuotes.GetWma(period).ToList();
var sResult = _testData.SkenderQuotes.GetWma(period).ToList();
// Compare last 100 records
VerifyData_Skender(qResult, sResult);
ValidationHelper.VerifyData(qResult, sResult, x => x.Wma);
}
_output.WriteLine("WMA Batch(TSeries) validated successfully against Skender");
}
@@ -72,16 +52,16 @@ public class WmaValidationTests
// Calculate QuanTAlib WMA (streaming)
var wma = new global::QuanTAlib.Wma(period);
var qResults = new List<double>();
foreach (var item in _data)
foreach (var item in _testData.Data)
{
qResults.Add(wma.Update(item).Value);
}
// Calculate Skender WMA
var sResult = _skenderQuotes.GetWma(period).ToList();
var sResult = _testData.SkenderQuotes.GetWma(period).ToList();
// Compare last 100 records
VerifyData_Skender_Streaming(qResults, sResult);
ValidationHelper.VerifyData(qResults, sResult, x => x.Wma);
}
_output.WriteLine("WMA Streaming validated successfully against Skender");
}
@@ -91,20 +71,17 @@ public class WmaValidationTests
{
int[] periods = { 5, 10, 20, 50, 100 };
// Prepare data for Span API
double[] sourceData = _data.Select(x => x.Value).ToArray();
foreach (var period in periods)
{
// Calculate QuanTAlib WMA (Span API)
double[] qOutput = new double[sourceData.Length];
global::QuanTAlib.Wma.Calculate(sourceData.AsSpan(), qOutput.AsSpan(), period);
double[] qOutput = new double[_testData.RawData.Length];
global::QuanTAlib.Wma.Calculate(_testData.RawData.Span, qOutput.AsSpan(), period);
// Calculate Skender WMA
var sResult = _skenderQuotes.GetWma(period).ToList();
var sResult = _testData.SkenderQuotes.GetWma(period).ToList();
// Compare last 100 records
VerifyData_Skender_Span(qOutput, sResult);
ValidationHelper.VerifyData(qOutput, sResult, x => x.Wma);
}
_output.WriteLine("WMA Span validated successfully against Skender");
}
@@ -115,23 +92,22 @@ public class WmaValidationTests
int[] periods = { 5, 10, 20, 50, 100 };
// Prepare data for TA-Lib (double[])
double[] tData = _data.Select(x => x.Value).ToArray();
double[] output = new double[tData.Length];
double[] output = new double[_testData.RawData.Length];
foreach (var period in periods)
{
// Calculate QuanTAlib WMA (batch TSeries)
var wma = new global::QuanTAlib.Wma(period);
var qResult = wma.Update(_data);
var qResult = wma.Update(_testData.Data);
// Calculate TA-Lib WMA
var retCode = TALib.Functions.Wma<double>(tData, 0..^0, output, out var outRange, period);
var retCode = TALib.Functions.Wma<double>(_testData.RawData.Span, 0..^0, output, out var outRange, period);
Assert.Equal(Core.RetCode.Success, retCode);
int lookback = TALib.Functions.WmaLookback(period);
// Compare last 100 records
VerifyData_Talib(qResult, output, outRange, lookback);
ValidationHelper.VerifyData(qResult, output, outRange, lookback, tolerance: 1e-4);
}
_output.WriteLine("WMA Batch(TSeries) validated successfully against TA-Lib");
}
@@ -142,27 +118,26 @@ public class WmaValidationTests
int[] periods = { 5, 10, 20, 50, 100 };
// Prepare data for TA-Lib (double[])
double[] tData = _data.Select(x => x.Value).ToArray();
double[] output = new double[tData.Length];
double[] output = new double[_testData.RawData.Length];
foreach (var period in periods)
{
// Calculate QuanTAlib WMA (streaming)
var wma = new global::QuanTAlib.Wma(period);
var qResults = new List<double>();
foreach (var item in _data)
foreach (var item in _testData.Data)
{
qResults.Add(wma.Update(item).Value);
}
// Calculate TA-Lib WMA
var retCode = TALib.Functions.Wma<double>(tData, 0..^0, output, out var outRange, period);
var retCode = TALib.Functions.Wma<double>(_testData.RawData.Span, 0..^0, output, out var outRange, period);
Assert.Equal(Core.RetCode.Success, retCode);
int lookback = TALib.Functions.WmaLookback(period);
// Compare last 100 records
VerifyData_Talib_Streaming(qResults, output, outRange, lookback);
ValidationHelper.VerifyData(qResults, output, outRange, lookback, tolerance: 1e-4);
}
_output.WriteLine("WMA Streaming validated successfully against TA-Lib");
}
@@ -173,23 +148,22 @@ public class WmaValidationTests
int[] periods = { 5, 10, 20, 50, 100 };
// Prepare data
double[] sourceData = _data.Select(x => x.Value).ToArray();
double[] talibOutput = new double[sourceData.Length];
double[] talibOutput = new double[_testData.RawData.Length];
foreach (var period in periods)
{
// Calculate QuanTAlib WMA (Span API)
double[] qOutput = new double[sourceData.Length];
global::QuanTAlib.Wma.Calculate(sourceData.AsSpan(), qOutput.AsSpan(), period);
double[] qOutput = new double[_testData.RawData.Length];
global::QuanTAlib.Wma.Calculate(_testData.RawData.Span, qOutput.AsSpan(), period);
// Calculate TA-Lib WMA
var retCode = TALib.Functions.Wma<double>(sourceData, 0..^0, talibOutput, out var outRange, period);
var retCode = TALib.Functions.Wma<double>(_testData.RawData.Span, 0..^0, talibOutput, out var outRange, period);
Assert.Equal(Core.RetCode.Success, retCode);
int lookback = TALib.Functions.WmaLookback(period);
// Compare last 100 records
VerifyData_Talib_Span(qOutput, talibOutput, outRange, lookback);
ValidationHelper.VerifyData(qOutput, talibOutput, outRange, lookback, tolerance: 1e-4);
}
_output.WriteLine("WMA Span validated successfully against TA-Lib");
}
@@ -199,27 +173,24 @@ public class WmaValidationTests
{
int[] periods = { 5, 10, 20, 50, 100 };
// Prepare data for Tulip (double[])
double[] tData = _data.Select(x => x.Value).ToArray();
foreach (var period in periods)
{
// Calculate QuanTAlib WMA (batch TSeries)
var wma = new global::QuanTAlib.Wma(period);
var qResult = wma.Update(_data);
var qResult = wma.Update(_testData.Data);
// Calculate Tulip WMA
var wmaIndicator = Tulip.Indicators.wma;
double[][] inputs = { tData };
double[][] inputs = { _testData.RawData.ToArray() };
double[] options = { period };
int lookback = period - 1;
double[][] outputs = { new double[tData.Length - lookback] };
double[][] outputs = { new double[_testData.RawData.Length - lookback] };
wmaIndicator.Run(inputs, options, outputs);
var tResult = outputs[0];
// Compare last 100 records
VerifyData_Tulip(qResult, tResult, lookback);
ValidationHelper.VerifyData(qResult, tResult, lookback, tolerance: 1e-4);
}
_output.WriteLine("WMA Batch(TSeries) validated successfully against Tulip");
}
@@ -229,31 +200,28 @@ public class WmaValidationTests
{
int[] periods = { 5, 10, 20, 50, 100 };
// Prepare data for Tulip (double[])
double[] tData = _data.Select(x => x.Value).ToArray();
foreach (var period in periods)
{
// Calculate QuanTAlib WMA (streaming)
var wma = new global::QuanTAlib.Wma(period);
var qResults = new List<double>();
foreach (var item in _data)
foreach (var item in _testData.Data)
{
qResults.Add(wma.Update(item).Value);
}
// Calculate Tulip WMA
var wmaIndicator = Tulip.Indicators.wma;
double[][] inputs = { tData };
double[][] inputs = { _testData.RawData.ToArray() };
double[] options = { period };
int lookback = period - 1;
double[][] outputs = { new double[tData.Length - lookback] };
double[][] outputs = { new double[_testData.RawData.Length - lookback] };
wmaIndicator.Run(inputs, options, outputs);
var tResult = outputs[0];
// Compare last 100 records
VerifyData_Tulip_Streaming(qResults, tResult, lookback);
ValidationHelper.VerifyData(qResults, tResult, lookback, tolerance: 1e-4);
}
_output.WriteLine("WMA Streaming validated successfully against Tulip");
}
@@ -263,207 +231,58 @@ public class WmaValidationTests
{
int[] periods = { 5, 10, 20, 50, 100 };
// Prepare data
double[] sourceData = _data.Select(x => x.Value).ToArray();
foreach (var period in periods)
{
// Calculate QuanTAlib WMA (Span API)
double[] qOutput = new double[sourceData.Length];
global::QuanTAlib.Wma.Calculate(sourceData.AsSpan(), qOutput.AsSpan(), period);
double[] qOutput = new double[_testData.RawData.Length];
global::QuanTAlib.Wma.Calculate(_testData.RawData.Span, qOutput.AsSpan(), period);
// Calculate Tulip WMA
var wmaIndicator = Tulip.Indicators.wma;
double[][] inputs = { sourceData };
double[][] inputs = { _testData.RawData.ToArray() };
double[] options = { period };
int lookback = period - 1;
double[][] outputs = { new double[sourceData.Length - lookback] };
double[][] outputs = { new double[_testData.RawData.Length - lookback] };
wmaIndicator.Run(inputs, options, outputs);
var tResult = outputs[0];
// Compare last 100 records
VerifyData_Tulip_Span(qOutput, tResult, lookback);
ValidationHelper.VerifyData(qOutput, tResult, lookback, tolerance: 1e-4);
}
_output.WriteLine("WMA Span validated successfully against Tulip");
}
// ==================== Verification Helpers ====================
private static void VerifyData_Skender(TSeries qSeries, List<WmaResult> sSeries)
[Fact]
public void Validate_Against_Ooples()
{
Assert.Equal(qSeries.Count, sSeries.Count);
int[] periods = { 5, 10, 20, 50, 100 };
int count = qSeries.Count;
int skip = count - 100;
for (int i = skip; i < count; i++)
// Prepare data for Ooples (List<TickerData>)
var ooplesData = _testData.SkenderQuotes.Select(q => new TickerData
{
double qValue = qSeries[i].Value;
double? sValue = sSeries[i].Wma;
Date = q.Date,
Close = (double)q.Close,
High = (double)q.High,
Low = (double)q.Low,
Open = (double)q.Open,
Volume = (double)q.Volume
}).ToList();
if (!sValue.HasValue) continue;
Assert.Equal(sValue.Value, qValue, 1e-6);
}
}
private static void VerifyData_Skender_Streaming(List<double> qResults, List<WmaResult> sSeries)
{
Assert.Equal(qResults.Count, sSeries.Count);
int count = qResults.Count;
int skip = count - 100;
for (int i = skip; i < count; i++)
foreach (var period in periods)
{
double qValue = qResults[i];
double? sValue = sSeries[i].Wma;
// Calculate QuanTAlib WMA
var wma = new global::QuanTAlib.Wma(period);
var qResult = wma.Update(_testData.Data);
if (!sValue.HasValue) continue;
// Calculate Ooples WMA
var stockData = new StockData(ooplesData);
var oResult = stockData.CalculateWeightedMovingAverage(length: period);
var oValues = oResult.OutputValues["Wma"];
Assert.Equal(sValue.Value, qValue, 1e-6);
}
}
private static void VerifyData_Skender_Span(double[] qOutput, List<WmaResult> sSeries)
{
Assert.Equal(qOutput.Length, sSeries.Count);
int count = qOutput.Length;
int skip = count - 100;
for (int i = skip; i < count; i++)
{
double qValue = qOutput[i];
double? sValue = sSeries[i].Wma;
if (!sValue.HasValue) continue;
Assert.Equal(sValue.Value, qValue, 1e-6);
}
}
private static void VerifyData_Talib(TSeries qSeries, double[] tOutput, Range outRange, int lookback)
{
int count = qSeries.Count;
int skip = count - 100;
int validCount = outRange.End.Value - outRange.Start.Value;
for (int i = skip; i < count; i++)
{
double qValue = qSeries[i].Value;
if (i < lookback) continue;
int tIndex = i - lookback;
if (tIndex >= validCount) continue;
double tValue = tOutput[tIndex];
Assert.Equal(tValue, qValue, 1e-6);
}
}
private static void VerifyData_Talib_Streaming(List<double> qResults, double[] tOutput, Range outRange, int lookback)
{
int count = qResults.Count;
int skip = count - 100;
int validCount = outRange.End.Value - outRange.Start.Value;
for (int i = skip; i < count; i++)
{
double qValue = qResults[i];
if (i < lookback) continue;
int tIndex = i - lookback;
if (tIndex >= validCount) continue;
double tValue = tOutput[tIndex];
Assert.Equal(tValue, qValue, 1e-6);
}
}
private static void VerifyData_Talib_Span(double[] qOutput, double[] tOutput, Range outRange, int lookback)
{
int count = qOutput.Length;
int skip = count - 100;
int validCount = outRange.End.Value - outRange.Start.Value;
for (int i = skip; i < count; i++)
{
double qValue = qOutput[i];
if (i < lookback) continue;
int tIndex = i - lookback;
if (tIndex >= validCount) continue;
double tValue = tOutput[tIndex];
Assert.Equal(tValue, qValue, 1e-6);
}
}
private static void VerifyData_Tulip(TSeries qSeries, double[] tOutput, int lookback)
{
int count = qSeries.Count;
int skip = count - 100;
for (int i = skip; i < count; i++)
{
double qValue = qSeries[i].Value;
if (i < lookback) continue;
int tIndex = i - lookback;
if (tIndex >= tOutput.Length) continue;
double tValue = tOutput[tIndex];
Assert.Equal(tValue, qValue, 1e-6);
}
}
private static void VerifyData_Tulip_Streaming(List<double> qResults, double[] tOutput, int lookback)
{
int count = qResults.Count;
int skip = count - 100;
for (int i = skip; i < count; i++)
{
double qValue = qResults[i];
if (i < lookback) continue;
int tIndex = i - lookback;
if (tIndex >= tOutput.Length) continue;
double tValue = tOutput[tIndex];
Assert.Equal(tValue, qValue, 1e-6);
}
}
private static void VerifyData_Tulip_Span(double[] qOutput, double[] tOutput, int lookback)
{
int count = qOutput.Length;
int skip = count - 100;
for (int i = skip; i < count; i++)
{
double qValue = qOutput[i];
if (i < lookback) continue;
int tIndex = i - lookback;
if (tIndex >= tOutput.Length) continue;
double tValue = tOutput[tIndex];
Assert.Equal(tValue, qValue, 1e-6);
// Compare
ValidationHelper.VerifyData(qResult, oValues, (s) => s, tolerance: 5e-4);
}
_output.WriteLine("WMA validated successfully against Ooples");
}
}