mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-24 21:48:03 +00:00
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
This commit is contained in:
Miha Kralj
@@ -0,0 +1,154 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using QuanTAlib;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class LrsiIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void LrsiIndicator_Constructor_SetsDefaults()
|
||||
{
|
||||
var indicator = new LrsiIndicator();
|
||||
|
||||
Assert.Equal(0.5, indicator.Gamma);
|
||||
Assert.Equal(SourceType.Close, indicator.Source);
|
||||
Assert.True(indicator.ShowColdValues);
|
||||
Assert.Equal("LRSI - Laguerre RSI", indicator.Name);
|
||||
Assert.True(indicator.SeparateWindow);
|
||||
Assert.True(indicator.OnBackGround);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_MinHistoryDepths_EqualsFour()
|
||||
{
|
||||
var indicator = new LrsiIndicator();
|
||||
|
||||
Assert.Equal(4, LrsiIndicator.MinHistoryDepths);
|
||||
IWatchlistIndicator watchlistIndicator = indicator;
|
||||
Assert.Equal(4, watchlistIndicator.MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_ShortName_IncludesGamma()
|
||||
{
|
||||
var indicator = new LrsiIndicator { Gamma = 0.75 };
|
||||
indicator.Initialize();
|
||||
|
||||
Assert.Contains("LRSI", indicator.ShortName, StringComparison.Ordinal);
|
||||
Assert.Contains("0.75", indicator.ShortName, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_SourceCodeLink_IsValid()
|
||||
{
|
||||
var indicator = new LrsiIndicator();
|
||||
|
||||
Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
Assert.Contains("Lrsi.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_Initialize_CreatesLineSeries()
|
||||
{
|
||||
var indicator = new LrsiIndicator { Gamma = 0.5 };
|
||||
|
||||
indicator.Initialize();
|
||||
|
||||
Assert.Single(indicator.LinesSeries);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
|
||||
{
|
||||
var indicator = new LrsiIndicator { Gamma = 0.5 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
double price = 100.0 + Math.Sin(i * 0.3) * 10.0 + i * 0.1;
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), price + 5, price + 10, price - 5, price);
|
||||
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
}
|
||||
|
||||
double value = indicator.LinesSeries[0].GetValue(0);
|
||||
Assert.True(double.IsFinite(value));
|
||||
Assert.True(value >= 0.0 && value <= 1.0, $"LRSI={value} out of [0,1]");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_ProcessUpdate_NewBar_ComputesValue()
|
||||
{
|
||||
var indicator = new LrsiIndicator { Gamma = 0.5 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
double price = 100.0 + i * 0.5;
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), price + 3, price + 6, price - 3, price);
|
||||
|
||||
var reason = i < 19 ? UpdateReason.HistoricalBar : UpdateReason.NewBar;
|
||||
var args = new UpdateArgs(reason);
|
||||
indicator.ProcessUpdate(args);
|
||||
}
|
||||
|
||||
double value = indicator.LinesSeries[0].GetValue(0);
|
||||
Assert.True(double.IsFinite(value));
|
||||
Assert.True(value >= 0.0 && value <= 1.0, $"LRSI={value} out of [0,1]");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_DifferentSourceTypes_ComputeWithoutError()
|
||||
{
|
||||
foreach (var sourceType in new[] { SourceType.Close, SourceType.Open, SourceType.High, SourceType.Low })
|
||||
{
|
||||
var indicator = new LrsiIndicator
|
||||
{
|
||||
Gamma = 0.5,
|
||||
Source = sourceType
|
||||
};
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), price, price + 5, price - 5, price + 1);
|
||||
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
}
|
||||
|
||||
double value = indicator.LinesSeries[0].GetValue(0);
|
||||
Assert.True(double.IsFinite(value), $"SourceType {sourceType}: value={value}");
|
||||
Assert.True(value >= 0.0 && value <= 1.0, $"SourceType {sourceType}: LRSI={value} out of [0,1]");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LrsiIndicator_OutputInRange_ExtendedSeries()
|
||||
{
|
||||
var indicator = new LrsiIndicator { Gamma = 0.5 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
// Feed a volatile sine wave to exercise full range
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
double price = 100.0 + Math.Sin(i * 0.2) * 20.0;
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), price + 5, price + 10, price - 5, price);
|
||||
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
|
||||
double v = indicator.LinesSeries[0].GetValue(0);
|
||||
if (double.IsFinite(v))
|
||||
{
|
||||
Assert.True(v >= 0.0 && v <= 1.0, $"Bar {i}: LRSI={v} out of [0,1]");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,483 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class LrsiTests
|
||||
{
|
||||
private const double Tolerance = 1e-10;
|
||||
|
||||
// ───── A) Constructor validation ─────
|
||||
|
||||
[Fact]
|
||||
public void Constructor_GammaNegative_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Lrsi(gamma: -0.1));
|
||||
Assert.Equal("gamma", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_GammaGreaterThanOne_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Lrsi(gamma: 1.1));
|
||||
Assert.Equal("gamma", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_GammaZero_IsValid()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.0);
|
||||
Assert.Equal(0.0, lrsi.Gamma);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_GammaOne_IsValid()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 1.0);
|
||||
Assert.Equal(1.0, lrsi.Gamma);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_DefaultGamma_SetsProperties()
|
||||
{
|
||||
var lrsi = new Lrsi();
|
||||
Assert.Equal(0.5, lrsi.Gamma);
|
||||
Assert.Equal("Lrsi(0.50)", lrsi.Name);
|
||||
Assert.Equal(4, lrsi.WarmupPeriod);
|
||||
Assert.Equal(default, lrsi.Last);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_CustomGamma_SetsName()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.75);
|
||||
Assert.Equal("Lrsi(0.75)", lrsi.Name);
|
||||
Assert.Equal(0.75, lrsi.Gamma);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_OutputLengthMismatch_ThrowsArgumentException()
|
||||
{
|
||||
var src = new double[] { 1, 2, 3 };
|
||||
var out1 = new double[4];
|
||||
var ex = Assert.Throws<ArgumentException>(() => Lrsi.Calculate(src, out1));
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_GammaNegative_ThrowsArgumentException()
|
||||
{
|
||||
var src = new double[] { 1, 2, 3 };
|
||||
var out1 = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() => Lrsi.Calculate(src, out1, gamma: -0.1));
|
||||
Assert.Equal("gamma", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_GammaGreaterThanOne_ThrowsArgumentException()
|
||||
{
|
||||
var src = new double[] { 1, 2, 3 };
|
||||
var out1 = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() => Lrsi.Calculate(src, out1, gamma: 1.01));
|
||||
Assert.Equal("gamma", ex.ParamName);
|
||||
}
|
||||
|
||||
// ───── B) Basic calculation ─────
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsTValue()
|
||||
{
|
||||
var lrsi = new Lrsi();
|
||||
var result = lrsi.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.IsType<TValue>(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_OutputInRange0To1()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.3, seed: 42);
|
||||
var bars = gbm.Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
foreach (var bar in bars.Close)
|
||||
{
|
||||
double v = lrsi.Update(bar).Value;
|
||||
Assert.True(v >= 0.0 && v <= 1.0, $"LRSI={v} out of [0,1]");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NameIsAccessible()
|
||||
{
|
||||
var lrsi = new Lrsi(0.5);
|
||||
_ = lrsi.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.Equal("Lrsi(0.50)", lrsi.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_LastIsAccessible()
|
||||
{
|
||||
var lrsi = new Lrsi();
|
||||
var t = new TValue(DateTime.UtcNow, 100.0);
|
||||
var result = lrsi.Update(t);
|
||||
Assert.Equal(result, lrsi.Last);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_ConstantPrice_ProducesHalfPoint()
|
||||
{
|
||||
// Constant input → all stages equal → cu=cd=0 → LRSI = 0.5
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var t = DateTime.UtcNow;
|
||||
double last = 0;
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
last = lrsi.Update(new TValue(t.AddMinutes(i), 100.0)).Value;
|
||||
}
|
||||
Assert.Equal(0.5, last, 1e-6);
|
||||
}
|
||||
|
||||
// ───── C) State + bar correction ─────
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNewTrue_AdvancesState()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var t = DateTime.UtcNow;
|
||||
lrsi.Update(new TValue(t, 100.0), isNew: true);
|
||||
var v1 = lrsi.Last;
|
||||
lrsi.Update(new TValue(t.AddMinutes(1), 105.0), isNew: true);
|
||||
var v2 = lrsi.Last;
|
||||
Assert.NotEqual(default, v1);
|
||||
Assert.NotEqual(default, v2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNewFalse_RollsBack()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
double[] prices = [100, 102, 104, 103, 105, 107, 106, 108, 110, 109, 111, 113];
|
||||
var t = DateTime.UtcNow;
|
||||
for (int i = 0; i < prices.Length; i++)
|
||||
{
|
||||
lrsi.Update(new TValue(t.AddMinutes(i), prices[i]), isNew: true);
|
||||
}
|
||||
|
||||
// Correction with a different price
|
||||
lrsi.Update(new TValue(t.AddMinutes(prices.Length), 150.0), isNew: false);
|
||||
var corrected1 = lrsi.Last.Value;
|
||||
|
||||
// Same correction again must be idempotent
|
||||
lrsi.Update(new TValue(t.AddMinutes(prices.Length), 150.0), isNew: false);
|
||||
var corrected2 = lrsi.Last.Value;
|
||||
|
||||
Assert.Equal(corrected1, corrected2, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IterativeCorrections_Restore()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
double[] prices = [100, 102, 98, 105, 103, 107, 101, 108, 100, 109, 102, 110];
|
||||
var t = DateTime.UtcNow;
|
||||
for (int i = 0; i < prices.Length; i++)
|
||||
{
|
||||
lrsi.Update(new TValue(t.AddMinutes(i), prices[i]), isNew: true);
|
||||
}
|
||||
|
||||
// Capture last isNew=true state
|
||||
var baseline = lrsi.Last.Value;
|
||||
|
||||
// Multiple corrections (each restores to prior state before applying new price)
|
||||
lrsi.Update(new TValue(t.AddMinutes(prices.Length), 90.0), isNew: false);
|
||||
lrsi.Update(new TValue(t.AddMinutes(prices.Length), 120.0), isNew: false);
|
||||
lrsi.Update(new TValue(t.AddMinutes(prices.Length), prices[^1]), isNew: false);
|
||||
|
||||
// Correction with same price as last isNew=true should reproduce baseline
|
||||
Assert.Equal(baseline, lrsi.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_Reset_ClearsState()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 7);
|
||||
var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
foreach (var bar in bars.Close)
|
||||
{
|
||||
lrsi.Update(bar, isNew: true);
|
||||
}
|
||||
|
||||
lrsi.Reset();
|
||||
Assert.False(lrsi.IsHot);
|
||||
Assert.Equal(default, lrsi.Last);
|
||||
}
|
||||
|
||||
// ───── D) Warmup / convergence ─────
|
||||
|
||||
[Fact]
|
||||
public void WarmupPeriod_IsFour()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
Assert.Equal(4, lrsi.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_FlipsAfterFirstBar()
|
||||
{
|
||||
// LRSI starts hot after first non-zero input moves any filter stage
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
Assert.False(lrsi.IsHot);
|
||||
|
||||
// After first price update the filter stages become non-zero
|
||||
lrsi.Update(new TValue(DateTime.UtcNow, 100.0), isNew: true);
|
||||
Assert.True(lrsi.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_RemainsHotAfterReset_ReturnsToFalse()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
lrsi.Update(new TValue(DateTime.UtcNow, 100.0), isNew: true);
|
||||
Assert.True(lrsi.IsHot);
|
||||
lrsi.Reset();
|
||||
Assert.False(lrsi.IsHot);
|
||||
}
|
||||
|
||||
// ───── E) Robustness: NaN / Infinity ─────
|
||||
|
||||
[Fact]
|
||||
public void Update_NaN_UsesLastValid()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var t = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
lrsi.Update(new TValue(t.AddMinutes(i), 100.0 + i), isNew: true);
|
||||
}
|
||||
|
||||
var result = lrsi.Update(new TValue(t.AddMinutes(20), double.NaN), isNew: true);
|
||||
Assert.True(double.IsFinite(result.Value), $"Expected finite, got {result.Value}");
|
||||
Assert.True(result.Value >= 0.0 && result.Value <= 1.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_PositiveInfinity_UsesLastValid()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var t = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
lrsi.Update(new TValue(t.AddMinutes(i), 100.0 + i), isNew: true);
|
||||
}
|
||||
|
||||
var result = lrsi.Update(new TValue(t.AddMinutes(20), double.PositiveInfinity), isNew: true);
|
||||
Assert.True(double.IsFinite(result.Value), $"Expected finite, got {result.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NegativeInfinity_UsesLastValid()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var t = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
lrsi.Update(new TValue(t.AddMinutes(i), 100.0 + i), isNew: true);
|
||||
}
|
||||
|
||||
var result = lrsi.Update(new TValue(t.AddMinutes(20), double.NegativeInfinity), isNew: true);
|
||||
Assert.True(double.IsFinite(result.Value), $"Expected finite, got {result.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_BatchNaN_AllFinite()
|
||||
{
|
||||
var lrsi = new Lrsi(gamma: 0.5);
|
||||
var t = DateTime.UtcNow;
|
||||
|
||||
double[] prices = [100, 101, double.NaN, 102, 103, double.NaN, double.NaN, 104, 105, 106,
|
||||
107, 108, 109, 110, 111, 112, 113, 114, 115, 116];
|
||||
for (int i = 0; i < prices.Length; i++)
|
||||
{
|
||||
var result = lrsi.Update(new TValue(t.AddMinutes(i), prices[i]), isNew: true);
|
||||
Assert.True(double.IsFinite(result.Value), $"Not finite at index {i}: {result.Value}");
|
||||
Assert.True(result.Value >= 0.0 && result.Value <= 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
// ───── F) Consistency: batch == streaming == span == eventing ─────
|
||||
|
||||
[Fact]
|
||||
public void Consistency_BatchTSeries_MatchesStreaming()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 2001);
|
||||
var bars = gbm.Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
// Streaming
|
||||
var streaming = new Lrsi(0.5);
|
||||
var streamVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streamVals[i] = streaming.Update(source[i]).Value;
|
||||
}
|
||||
|
||||
// Batch TSeries
|
||||
TSeries batchTs = Lrsi.Calculate(source, 0.5);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(streamVals[i], batchTs.Values[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Consistency_BatchSpan_MatchesBatchTSeries()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 2002);
|
||||
var bars = gbm.Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
TSeries batchTs = Lrsi.Calculate(source, 0.5);
|
||||
|
||||
var spanOut = new double[source.Count];
|
||||
Lrsi.Calculate(source.Values, spanOut, 0.5);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchTs.Values[i], spanOut[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Consistency_Eventing_MatchesStreaming()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 2003);
|
||||
var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
// Streaming
|
||||
var streaming = new Lrsi(0.5);
|
||||
var streamVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streamVals[i] = streaming.Update(source[i]).Value;
|
||||
}
|
||||
|
||||
// Event-based
|
||||
var eventTs = new TSeries();
|
||||
var eventLrsi = new Lrsi(eventTs, 0.5);
|
||||
var eventVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
eventTs.Add(source[i]);
|
||||
eventVals[i] = eventLrsi.Last.Value;
|
||||
}
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(streamVals[i], eventVals[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ───── G) Span API tests ─────
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_EmptySource_DoesNotThrow()
|
||||
{
|
||||
var src = Array.Empty<double>();
|
||||
var out1 = Array.Empty<double>();
|
||||
Lrsi.Calculate(src, out1);
|
||||
Assert.Empty(out1);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_LargeData_UsesArrayPool()
|
||||
{
|
||||
// 257 exceeds StackallocThreshold=256; LRSI has no internal buffer
|
||||
// but we exercise the span path with large data (no stack overflow risk here)
|
||||
int n = 500;
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 9999);
|
||||
var bars = gbm.Fetch(n, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var src = bars.Close.Values;
|
||||
var out1 = new double[n];
|
||||
|
||||
Lrsi.Calculate(src, out1);
|
||||
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
Assert.True(out1[i] >= 0.0 && out1[i] <= 1.0, $"out1[{i}]={out1[i]} out of [0,1]");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_WithNaN_AllOutputsFinite()
|
||||
{
|
||||
double[] src = [100, 101, double.NaN, 102, 103, double.NaN, 104, 105];
|
||||
var out1 = new double[src.Length];
|
||||
|
||||
Lrsi.Calculate(src, out1);
|
||||
|
||||
for (int i = 0; i < out1.Length; i++)
|
||||
{
|
||||
Assert.True(double.IsFinite(out1[i]), $"out1[{i}]={out1[i]} not finite");
|
||||
Assert.True(out1[i] >= 0.0 && out1[i] <= 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_OutputAlwaysInRange()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 50.0, mu: 0.05, sigma: 0.5, seed: 777);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var src = bars.Close.Values;
|
||||
var out1 = new double[src.Length];
|
||||
|
||||
Lrsi.Calculate(src, out1);
|
||||
|
||||
for (int i = 0; i < src.Length; i++)
|
||||
{
|
||||
Assert.True(out1[i] >= 0.0 && out1[i] <= 1.0, $"out1[{i}]={out1[i]} out of [0,1]");
|
||||
}
|
||||
}
|
||||
|
||||
// ───── H) Chainability ─────
|
||||
|
||||
[Fact]
|
||||
public void Chainability_PubFires()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var lrsi = new Lrsi(source, 0.5);
|
||||
|
||||
int count = 0;
|
||||
lrsi.Pub += (object? _, in TValueEventArgs e) => count++;
|
||||
|
||||
var t = DateTime.UtcNow;
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
source.Add(new TValue(t.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
Assert.Equal(10, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Chainability_EventBasedChaining_Works()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var lrsi = new Lrsi(source, 0.5);
|
||||
var output = new TSeries();
|
||||
lrsi.Pub += (object? _, in TValueEventArgs e) => output.Add(e.Value);
|
||||
|
||||
var t = DateTime.UtcNow;
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
source.Add(new TValue(t.AddMinutes(i), 100.0 + i * 0.5));
|
||||
}
|
||||
|
||||
Assert.Equal(30, output.Count);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,353 @@
|
||||
using Xunit;
|
||||
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Self-consistency validation for LRSI.
|
||||
/// LRSI is not implemented in Skender, TA-Lib, Tulip, or Ooples — validation uses:
|
||||
/// 1. Batch TSeries == streaming consistency
|
||||
/// 2. Calculate(Span) == Calculate(TSeries) consistency
|
||||
/// 3. Eventing path matches streaming
|
||||
/// 4. Output always in [0, 1] under all conditions
|
||||
/// 5. Higher gamma produces smoother (lower variance) output than lower gamma
|
||||
/// 6. Gamma effect: high gamma retains more memory (slower response)
|
||||
/// 7. Determinism: same seed → identical results
|
||||
/// </summary>
|
||||
public sealed class LrsiValidationTests
|
||||
{
|
||||
private const double Tolerance = 1e-10;
|
||||
|
||||
// ── Self-consistency: batch TSeries == streaming ──
|
||||
|
||||
[Fact]
|
||||
public void Streaming_MatchesBatch_DefaultGamma()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 3001);
|
||||
var bars = gbm.Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
var streaming = new Lrsi(0.5);
|
||||
var streamVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streamVals[i] = streaming.Update(source[i]).Value;
|
||||
}
|
||||
|
||||
TSeries batchTs = Lrsi.Calculate(source, 0.5);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(streamVals[i], batchTs.Values[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_MatchesBatch_LowGamma()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.3, seed: 3002);
|
||||
var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
var streaming = new Lrsi(0.1);
|
||||
var streamVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streamVals[i] = streaming.Update(source[i]).Value;
|
||||
}
|
||||
|
||||
TSeries batchTs = Lrsi.Calculate(source, 0.1);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(streamVals[i], batchTs.Values[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_MatchesBatch_HighGamma()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 3003);
|
||||
var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
var streaming = new Lrsi(0.9);
|
||||
var streamVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streamVals[i] = streaming.Update(source[i]).Value;
|
||||
}
|
||||
|
||||
TSeries batchTs = Lrsi.Calculate(source, 0.9);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(streamVals[i], batchTs.Values[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Self-consistency: Span == TSeries ──
|
||||
|
||||
[Fact]
|
||||
public void Span_MatchesBatch_DefaultGamma()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 3004);
|
||||
var bars = gbm.Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
TSeries batchTs = Lrsi.Calculate(source, 0.5);
|
||||
|
||||
var spanOut = new double[source.Count];
|
||||
Lrsi.Calculate(source.Values, spanOut, 0.5);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchTs.Values[i], spanOut[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Eventing_MatchesStreaming()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 3005);
|
||||
var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
TSeries source = bars.Close;
|
||||
|
||||
var streaming = new Lrsi(0.5);
|
||||
var streamVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streamVals[i] = streaming.Update(source[i]).Value;
|
||||
}
|
||||
|
||||
var eventTs = new TSeries();
|
||||
var eventLrsi = new Lrsi(eventTs, 0.5);
|
||||
var eventVals = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
eventTs.Add(source[i]);
|
||||
eventVals[i] = eventLrsi.Last.Value;
|
||||
}
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(streamVals[i], eventVals[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Output range: always in [0, 1] ──
|
||||
|
||||
[Fact]
|
||||
public void Output_AlwaysInRange0To1_HighVolatility()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 50.0, mu: 0.05, sigma: 0.8, seed: 3006);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var lrsi = new Lrsi(0.5);
|
||||
foreach (var bar in bars.Close)
|
||||
{
|
||||
double v = lrsi.Update(bar).Value;
|
||||
Assert.True(v >= 0.0 && v <= 1.0, $"LRSI={v} out of [0,1] at high vol");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Output_AlwaysInRange0To1_LowVolatility()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.001, sigma: 0.01, seed: 3007);
|
||||
var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var lrsi = new Lrsi(0.5);
|
||||
foreach (var bar in bars.Close)
|
||||
{
|
||||
double v = lrsi.Update(bar).Value;
|
||||
Assert.True(v >= 0.0 && v <= 1.0, $"LRSI={v} out of [0,1] at low vol");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Output_AlwaysInRange_AllGammaValues()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.25, seed: 3008);
|
||||
var bars = gbm.Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
foreach (double gamma in new[] { 0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0 })
|
||||
{
|
||||
var lrsi = new Lrsi(gamma);
|
||||
foreach (var bar in bars.Close)
|
||||
{
|
||||
double v = lrsi.Update(bar).Value;
|
||||
Assert.True(v >= 0.0 && v <= 1.0, $"gamma={gamma} LRSI={v} out of [0,1]");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Gamma effect: higher gamma = smoother = less total variation on noisy input ──
|
||||
|
||||
[Fact]
|
||||
public void HigherGamma_ProducesLessTotalVariation_OnZigzagInput()
|
||||
{
|
||||
// The Laguerre filter's gamma controls damping across all 4 stages.
|
||||
// High gamma (e.g. 0.9) heavily damps each stage → LRSI output changes slowly.
|
||||
// Low gamma (e.g. 0.1) passes through price changes quickly → LRSI oscillates more.
|
||||
//
|
||||
// We verify this via total variation: sum of |LRSI[i] - LRSI[i-1]| over a zigzag series.
|
||||
// High gamma must produce strictly lower total variation than low gamma.
|
||||
//
|
||||
// Note: After full convergence to flat, both gammas snap to LRSI=1 on first up-bar
|
||||
// because L1-L3 are all equal (no inter-stage difference to flip with gamma).
|
||||
// Zigzag avoids this degenerate case by continuously exercising all 4 filter stages.
|
||||
|
||||
var t = DateTime.UtcNow;
|
||||
const int n = 500;
|
||||
|
||||
var lrsiLow = new Lrsi(0.1); // fast: high variation
|
||||
var lrsiHigh = new Lrsi(0.9); // slow: low variation
|
||||
|
||||
double tvLow = 0.0;
|
||||
double tvHigh = 0.0;
|
||||
double prevLow = double.NaN;
|
||||
double prevHigh = double.NaN;
|
||||
|
||||
// Zigzag: alternates +3 / -3 around 100, giving constant up/down signal
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
double price = 100.0 + (i % 2 == 0 ? 3.0 : -3.0);
|
||||
double vL = lrsiLow.Update(new TValue(t.AddMinutes(i), price), isNew: true).Value;
|
||||
double vH = lrsiHigh.Update(new TValue(t.AddMinutes(i), price), isNew: true).Value;
|
||||
|
||||
if (!double.IsNaN(prevLow))
|
||||
{
|
||||
tvLow += Math.Abs(vL - prevLow);
|
||||
tvHigh += Math.Abs(vH - prevHigh);
|
||||
}
|
||||
|
||||
prevLow = vL;
|
||||
prevHigh = vH;
|
||||
}
|
||||
|
||||
Assert.True(tvHigh < tvLow,
|
||||
$"High gamma total variation ({tvHigh:F4}) should be less than low gamma ({tvLow:F4})");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GammaZero_IsMoreResponsiveThanGammaHalf()
|
||||
{
|
||||
// gamma=0: L0 = close, L1 = prevL0, L2 = prevL1, L3 = prevL2
|
||||
// gamma=0.5: smoothed response
|
||||
// After a sharp price move, gamma=0 should react more rapidly.
|
||||
var lrsi0 = new Lrsi(0.0);
|
||||
var lrsi5 = new Lrsi(0.5);
|
||||
|
||||
// Warm up with baseline
|
||||
var t = DateTime.UtcNow;
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
lrsi0.Update(new TValue(t.AddMinutes(i), 100.0), isNew: true);
|
||||
lrsi5.Update(new TValue(t.AddMinutes(i), 100.0), isNew: true);
|
||||
}
|
||||
|
||||
// Single large up-spike — gamma=0 should read more extreme
|
||||
double v0 = lrsi0.Update(new TValue(t.AddMinutes(20), 150.0), isNew: true).Value;
|
||||
double v5 = lrsi5.Update(new TValue(t.AddMinutes(20), 150.0), isNew: true).Value;
|
||||
|
||||
// gamma=0 reacts immediately to spike; gamma=0.5 absorbs it more gradually
|
||||
Assert.True(v0 >= v5, $"gamma=0 ({v0:F6}) should be >= gamma=0.5 ({v5:F6}) on upspike");
|
||||
}
|
||||
|
||||
// ── Determinism ──
|
||||
|
||||
[Fact]
|
||||
public void Determinism_SameSeed_ProducesIdenticalResults()
|
||||
{
|
||||
var gbm1 = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 5001);
|
||||
var gbm2 = new GBM(startPrice: 100.0, mu: 0.01, sigma: 0.2, seed: 5001);
|
||||
var bars1 = gbm1.Fetch(150, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var bars2 = gbm2.Fetch(150, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var l1 = new Lrsi(0.5);
|
||||
var l2 = new Lrsi(0.5);
|
||||
|
||||
for (int i = 0; i < bars1.Close.Count; i++)
|
||||
{
|
||||
double v1 = l1.Update(bars1.Close[i]).Value;
|
||||
double v2 = l2.Update(bars2.Close[i]).Value;
|
||||
Assert.Equal(v1, v2, Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Edge cases ──
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_EmptySource_ReturnsEmptyOutput()
|
||||
{
|
||||
var src = Array.Empty<double>();
|
||||
var out1 = Array.Empty<double>();
|
||||
Lrsi.Calculate(src, out1);
|
||||
Assert.Empty(out1);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_ConstantPrice_ProducesHalfPoint()
|
||||
{
|
||||
var lrsi = new Lrsi(0.5);
|
||||
var t = DateTime.UtcNow;
|
||||
double last = 0;
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
last = lrsi.Update(new TValue(t.AddMinutes(i), 100.0)).Value;
|
||||
}
|
||||
// Constant price → all stages converge → cu = cd = 0 → LRSI = 0.5
|
||||
Assert.Equal(0.5, last, 1e-6);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_MonotonicallyRising_ProducesHighValues()
|
||||
{
|
||||
// Strictly rising prices → L0 > L1 > L2 > L3 always after warmup → cu > 0, cd = 0 → LRSI = 1
|
||||
var lrsi = new Lrsi(0.3);
|
||||
var t = DateTime.UtcNow;
|
||||
double price = 100.0;
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
price += 1.0;
|
||||
lrsi.Update(new TValue(t.AddMinutes(i), price), isNew: true);
|
||||
}
|
||||
// Should converge near 1 after sustained rise
|
||||
Assert.True(lrsi.Last.Value > 0.8, $"Expected > 0.8 on sustained rise, got {lrsi.Last.Value:F4}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_MonotonicallyFalling_ProducesLowValues()
|
||||
{
|
||||
// Strictly falling prices → cd > 0, cu = 0 → LRSI converges near 0
|
||||
var lrsi = new Lrsi(0.3);
|
||||
var t = DateTime.UtcNow;
|
||||
double price = 200.0;
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
price -= 1.0;
|
||||
lrsi.Update(new TValue(t.AddMinutes(i), price), isNew: true);
|
||||
}
|
||||
Assert.True(lrsi.Last.Value < 0.2, $"Expected < 0.2 on sustained fall, got {lrsi.Last.Value:F4}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Lrsi_MatchesOoples_Structural()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var ooplesData = bars.Select(b => new TickerData
|
||||
{
|
||||
Date = new DateTime(b.Time, DateTimeKind.Utc),
|
||||
Open = b.Open, High = b.High, Low = b.Low,
|
||||
Close = b.Close, Volume = b.Volume
|
||||
}).ToList();
|
||||
var result = new StockData(ooplesData).CalculateEhlersLaguerreRelativeStrengthIndex();
|
||||
var values = result.CustomValuesList;
|
||||
int finiteCount = values.Count(v => double.IsFinite(v));
|
||||
Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user