mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-23 21:18:04 +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,127 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using QuanTAlib;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class FractalsIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void FractalsIndicator_Constructor_SetsDefaults()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
|
||||
Assert.True(indicator.ShowColdValues);
|
||||
Assert.Contains("FRACTALS", indicator.Name, StringComparison.Ordinal);
|
||||
Assert.False(indicator.SeparateWindow);
|
||||
Assert.True(indicator.OnBackGround);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_MinHistoryDepths_EqualsZero()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
|
||||
Assert.Equal(0, FractalsIndicator.MinHistoryDepths);
|
||||
IWatchlistIndicator watchlistIndicator = indicator;
|
||||
Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_ShortName_IsFractals()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
indicator.Initialize();
|
||||
|
||||
Assert.Contains("FRACTALS", indicator.ShortName, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_SourceCodeLink_IsValid()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
|
||||
Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
Assert.Contains("Fractals", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_Initialize_CreatesInternalIndicator()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
|
||||
indicator.Initialize();
|
||||
|
||||
// After init, line series should exist (UpFractal + DownFractal)
|
||||
Assert.Equal(2, indicator.LinesSeries.Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
// Create a pattern with varying highs/lows to generate fractals
|
||||
double basePrice = 100 + (i % 5 == 2 ? 10 : 0); // spike every 5th bar at position 2
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 5, basePrice + 2);
|
||||
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
}
|
||||
|
||||
double upFractal = indicator.LinesSeries[0].GetValue(0);
|
||||
double downFractal = indicator.LinesSeries[1].GetValue(0);
|
||||
|
||||
// Values should be set (either finite fractal or NaN=no fractal)
|
||||
Assert.True(double.IsFinite(upFractal) || double.IsNaN(upFractal));
|
||||
Assert.True(double.IsFinite(downFractal) || double.IsNaN(downFractal));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_ProcessUpdate_NewBar_ComputesValue()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
}
|
||||
|
||||
// Simulate a new bar
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(10), 110, 120, 100, 115);
|
||||
var newArgs = new UpdateArgs(UpdateReason.NewBar);
|
||||
indicator.ProcessUpdate(newArgs);
|
||||
|
||||
double upFractal = indicator.LinesSeries[0].GetValue(0);
|
||||
Assert.True(double.IsFinite(upFractal) || double.IsNaN(upFractal));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_TwoLineSeries_ArePresent()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
indicator.Initialize();
|
||||
|
||||
// UpFractal is index 0 (red), DownFractal is index 1 (green)
|
||||
Assert.Equal(2, indicator.LinesSeries.Count);
|
||||
Assert.Contains("Up", indicator.LinesSeries[0].Name, StringComparison.OrdinalIgnoreCase);
|
||||
Assert.Contains("Down", indicator.LinesSeries[1].Name, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FractalsIndicator_Description_IsSet()
|
||||
{
|
||||
var indicator = new FractalsIndicator();
|
||||
|
||||
Assert.NotNull(indicator.Description);
|
||||
Assert.NotEmpty(indicator.Description);
|
||||
Assert.Contains("fractal", indicator.Description, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,497 @@
|
||||
// FRACTALS Tests - Williams Fractals
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
// -- A) Constructor Validation ------------------------------------------------
|
||||
public sealed class FractalsConstructorTests
|
||||
{
|
||||
[Fact]
|
||||
public void Constructor_Default_SetsProperties()
|
||||
{
|
||||
var f = new Fractals();
|
||||
|
||||
Assert.Equal(5, f.WarmupPeriod);
|
||||
Assert.Contains("Fractals", f.Name, StringComparison.Ordinal);
|
||||
Assert.False(f.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_InitialState_NaN()
|
||||
{
|
||||
var f = new Fractals();
|
||||
|
||||
Assert.True(double.IsNaN(f.UpFractal));
|
||||
Assert.True(double.IsNaN(f.DownFractal));
|
||||
}
|
||||
}
|
||||
|
||||
// -- B) Basic Calculation -----------------------------------------------------
|
||||
public sealed class FractalsBasicTests
|
||||
{
|
||||
[Fact]
|
||||
public void Update_ReturnsTValue()
|
||||
{
|
||||
var f = new Fractals();
|
||||
// TBar(DateTime, open, high, low, close, volume)
|
||||
var bar = new TBar(DateTime.UtcNow, 97, 100, 95, 98, 1000);
|
||||
|
||||
TValue result = f.Update(bar);
|
||||
|
||||
Assert.IsType<TValue>(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_Last_IsAccessible()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var bar = new TBar(DateTime.UtcNow, 97, 100, 95, 98, 1000);
|
||||
|
||||
_ = f.Update(bar);
|
||||
|
||||
Assert.True(double.IsFinite(f.Last.Value) || double.IsNaN(f.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_KnownUpFractal_Detected()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var dt = DateTime.UtcNow;
|
||||
|
||||
// TBar(DateTime, open, high, low, close, volume)
|
||||
// Pattern: bar[4] low, bar[3] medium, bar[2] HIGH peak, bar[1] medium, bar[0] low
|
||||
// Bars fed in chronological order: bar[4] first, bar[0] last
|
||||
_ = f.Update(new TBar(dt.AddMinutes(0), 97, 100, 95, 98, 1000), isNew: true); // bar[4]: high=100
|
||||
_ = f.Update(new TBar(dt.AddMinutes(1), 100, 103, 98, 101, 1000), isNew: true); // bar[3]: high=103
|
||||
_ = f.Update(new TBar(dt.AddMinutes(2), 104, 110, 92, 105, 1000), isNew: true); // bar[2]: high=110 (peak)
|
||||
_ = f.Update(new TBar(dt.AddMinutes(3), 101, 104, 97, 102, 1000), isNew: true); // bar[1]: high=104
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 98, 101, 96, 99, 1000), isNew: true); // bar[0]: high=101
|
||||
|
||||
// bar[2].High=110 > bar[0].High=101, bar[1].High=104, bar[3].High=103, bar[4].High=100
|
||||
Assert.Equal(110.0, f.UpFractal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_KnownDownFractal_Detected()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var dt = DateTime.UtcNow;
|
||||
|
||||
// TBar(DateTime, open, high, low, close, volume)
|
||||
// Pattern: bar[4] high lows, bar[3] medium, bar[2] LOW trough, bar[1] medium, bar[0] high lows
|
||||
_ = f.Update(new TBar(dt.AddMinutes(0), 102, 105, 100, 103, 1000), isNew: true); // bar[4]: low=100
|
||||
_ = f.Update(new TBar(dt.AddMinutes(1), 100, 103, 98, 101, 1000), isNew: true); // bar[3]: low=98
|
||||
_ = f.Update(new TBar(dt.AddMinutes(2), 94, 102, 88, 95, 1000), isNew: true); // bar[2]: low=88 (trough)
|
||||
_ = f.Update(new TBar(dt.AddMinutes(3), 100, 104, 97, 101, 1000), isNew: true); // bar[1]: low=97
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 102, 106, 99, 103, 1000), isNew: true); // bar[0]: low=99
|
||||
|
||||
// bar[2].Low=88 < bar[0].Low=99, bar[1].Low=97, bar[3].Low=98, bar[4].Low=100
|
||||
Assert.Equal(88.0, f.DownFractal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NoFractal_ReturnsNaN()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var dt = DateTime.UtcNow;
|
||||
|
||||
// Monotone ascending - no fractal
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
double price = 100.0 + i * 5;
|
||||
_ = f.Update(new TBar(dt.AddMinutes(i), price, price + 2, price - 2, price + 1, 1000), isNew: true);
|
||||
}
|
||||
|
||||
Assert.True(double.IsNaN(f.UpFractal));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Name_ContainsFractals()
|
||||
{
|
||||
var f = new Fractals();
|
||||
Assert.Contains("Fractals", f.Name, StringComparison.Ordinal);
|
||||
}
|
||||
}
|
||||
|
||||
// -- C) State + Bar Correction ------------------------------------------------
|
||||
public sealed class FractalsStateCorrectionTests
|
||||
{
|
||||
[Fact]
|
||||
public void IsNew_True_AdvancesState()
|
||||
{
|
||||
var f = new Fractals();
|
||||
|
||||
_ = f.Update(new TBar(DateTime.UtcNow, 100, 105, 95, 100, 1000), isNew: true);
|
||||
var first = f.Last;
|
||||
|
||||
_ = f.Update(new TBar(DateTime.UtcNow.AddMinutes(1), 105, 110, 100, 105, 1000), isNew: true);
|
||||
var second = f.Last;
|
||||
|
||||
Assert.NotEqual(first.Time, second.Time);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsNew_False_CorrectionRestoresState()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var dt = DateTime.UtcNow;
|
||||
|
||||
// Feed 4 bars
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
_ = f.Update(new TBar(dt.AddMinutes(i), price, price + 5, price - 5, price + 1, 1000), isNew: true);
|
||||
}
|
||||
|
||||
// New bar
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 98, 110, 85, 100, 1000), isNew: true);
|
||||
|
||||
// Correct the bar (isNew=false with different values)
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 98, 111, 84, 100, 1000), isNew: false);
|
||||
|
||||
// Another correction with same values should produce same result
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 98, 111, 84, 100, 1000), isNew: false);
|
||||
var corrected1Up = f.UpFractal;
|
||||
var corrected1Down = f.DownFractal;
|
||||
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 98, 111, 84, 100, 1000), isNew: false);
|
||||
var corrected2Up = f.UpFractal;
|
||||
var corrected2Down = f.DownFractal;
|
||||
|
||||
Assert.Equal(corrected1Up, corrected2Up);
|
||||
Assert.Equal(corrected1Down, corrected2Down);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IterativeCorrections_ProduceSameResult()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var dt = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
_ = f.Update(new TBar(dt.AddMinutes(i), price, price + 5, price - 5, price + 1, 1000), isNew: true);
|
||||
}
|
||||
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 105, 110, 90, 100, 1000), isNew: true);
|
||||
|
||||
double[] upResults = new double[3];
|
||||
double[] downResults = new double[3];
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
_ = f.Update(new TBar(dt.AddMinutes(4), 106, 112, 88, 102, 1000), isNew: false);
|
||||
upResults[i] = f.UpFractal;
|
||||
downResults[i] = f.DownFractal;
|
||||
}
|
||||
|
||||
Assert.Equal(upResults[0], upResults[1]);
|
||||
Assert.Equal(upResults[1], upResults[2]);
|
||||
Assert.Equal(downResults[0], downResults[1]);
|
||||
Assert.Equal(downResults[1], downResults[2]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsAllState()
|
||||
{
|
||||
var f = new Fractals();
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
_ = f.Update(new TBar(DateTime.UtcNow.AddMinutes(i), price, price + 5, price - 5, price + 1, 1000));
|
||||
}
|
||||
|
||||
Assert.True(f.IsHot);
|
||||
|
||||
f.Reset();
|
||||
|
||||
Assert.False(f.IsHot);
|
||||
Assert.True(double.IsNaN(f.UpFractal));
|
||||
Assert.True(double.IsNaN(f.DownFractal));
|
||||
}
|
||||
}
|
||||
|
||||
// -- D) Warmup / Convergence --------------------------------------------------
|
||||
public sealed class FractalsWarmupTests
|
||||
{
|
||||
[Fact]
|
||||
public void IsHot_FlipsAfterWarmup()
|
||||
{
|
||||
var f = new Fractals();
|
||||
|
||||
// Feed 4 bars -- should NOT be hot
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
_ = f.Update(new TBar(DateTime.UtcNow.AddMinutes(i), price, price + 2, price - 2, price + 1, 1000));
|
||||
Assert.False(f.IsHot, $"Should not be hot at bar {i}");
|
||||
}
|
||||
|
||||
// Feed 5th bar -- should be hot
|
||||
double p = 100.0 + 4;
|
||||
_ = f.Update(new TBar(DateTime.UtcNow.AddMinutes(4), p, p + 2, p - 2, p + 1, 1000));
|
||||
Assert.True(f.IsHot, "Should be hot after 5 bars");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WarmupPeriod_Equals5()
|
||||
{
|
||||
var f = new Fractals();
|
||||
Assert.Equal(5, f.WarmupPeriod);
|
||||
}
|
||||
}
|
||||
|
||||
// -- E) Robustness ------------------------------------------------------------
|
||||
public sealed class FractalsRobustnessTests
|
||||
{
|
||||
[Fact]
|
||||
public void NaN_Input_UsesLastValidValue()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var dt = DateTime.UtcNow;
|
||||
|
||||
// Feed valid bars
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
_ = f.Update(new TBar(dt.AddMinutes(i), price, price + 5, price - 5, price + 1, 1000));
|
||||
}
|
||||
|
||||
Assert.True(f.IsHot);
|
||||
|
||||
// Feed NaN bar
|
||||
_ = f.Update(new TBar(dt.AddMinutes(5), double.NaN, double.NaN, double.NaN, double.NaN, 0));
|
||||
|
||||
// Should still be hot with valid fractal outputs (either NaN=no fractal or finite=fractal)
|
||||
Assert.True(f.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Infinity_Input_UsesLastValidValue()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var dt = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
_ = f.Update(new TBar(dt.AddMinutes(i), price, price + 5, price - 5, price + 1, 1000));
|
||||
}
|
||||
|
||||
_ = f.Update(new TBar(dt.AddMinutes(5),
|
||||
double.PositiveInfinity, double.PositiveInfinity, double.NegativeInfinity, double.PositiveInfinity, 0));
|
||||
|
||||
Assert.True(f.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FirstBar_NaN_ReturnsNaN()
|
||||
{
|
||||
var f = new Fractals();
|
||||
|
||||
_ = f.Update(new TBar(DateTime.UtcNow, double.NaN, double.NaN, double.NaN, double.NaN, 0));
|
||||
|
||||
Assert.True(double.IsNaN(f.Last.Value));
|
||||
}
|
||||
}
|
||||
|
||||
// -- F) Consistency -----------------------------------------------------------
|
||||
public sealed class FractalsConsistencyTests
|
||||
{
|
||||
private static TBarSeries CreateGbmBars(int count = 500)
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.20, seed: 42);
|
||||
return gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_MatchesBatch()
|
||||
{
|
||||
var bars = CreateGbmBars();
|
||||
|
||||
// Streaming
|
||||
var streaming = new Fractals();
|
||||
var streamUpResults = new double[bars.Count];
|
||||
for (int i = 0; i < bars.Count; i++)
|
||||
{
|
||||
_ = streaming.Update(bars[i], isNew: true);
|
||||
streamUpResults[i] = streaming.UpFractal;
|
||||
}
|
||||
|
||||
// Batch
|
||||
var batchResults = Fractals.Batch(bars);
|
||||
|
||||
int warmup = 4; // first 4 bars are NaN
|
||||
for (int i = warmup; i < bars.Count; i++)
|
||||
{
|
||||
if (double.IsNaN(streamUpResults[i]))
|
||||
{
|
||||
Assert.True(double.IsNaN(batchResults[i].Value));
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal(streamUpResults[i], batchResults[i].Value, precision: 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_MatchesSpan()
|
||||
{
|
||||
var bars = CreateGbmBars();
|
||||
|
||||
// Streaming
|
||||
var streaming = new Fractals();
|
||||
var streamUpResults = new double[bars.Count];
|
||||
var streamDownResults = new double[bars.Count];
|
||||
for (int i = 0; i < bars.Count; i++)
|
||||
{
|
||||
_ = streaming.Update(bars[i], isNew: true);
|
||||
streamUpResults[i] = streaming.UpFractal;
|
||||
streamDownResults[i] = streaming.DownFractal;
|
||||
}
|
||||
|
||||
// Span
|
||||
var spanUp = new double[bars.Count];
|
||||
var spanDown = new double[bars.Count];
|
||||
Fractals.Batch(bars.HighValues, bars.LowValues, spanUp, spanDown);
|
||||
|
||||
for (int i = 4; i < bars.Count; i++)
|
||||
{
|
||||
if (double.IsNaN(streamUpResults[i]))
|
||||
{
|
||||
Assert.True(double.IsNaN(spanUp[i]), $"Up fractal mismatch at {i}");
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal(streamUpResults[i], spanUp[i], precision: 10);
|
||||
}
|
||||
|
||||
if (double.IsNaN(streamDownResults[i]))
|
||||
{
|
||||
Assert.True(double.IsNaN(spanDown[i]), $"Down fractal mismatch at {i}");
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal(streamDownResults[i], spanDown[i], precision: 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TValue_Update_MatchesTBar_Update()
|
||||
{
|
||||
var f1 = new Fractals();
|
||||
var f2 = new Fractals();
|
||||
|
||||
double[] prices = [100, 102, 98, 105, 99, 103, 107, 95, 110, 108];
|
||||
|
||||
for (int i = 0; i < prices.Length; i++)
|
||||
{
|
||||
double p = prices[i];
|
||||
_ = f1.Update(new TBar(DateTime.UtcNow.AddMinutes(i), p, p, p, p, 0), isNew: true);
|
||||
_ = f2.Update(new TValue(DateTime.UtcNow.AddMinutes(i), p), isNew: true);
|
||||
}
|
||||
|
||||
Assert.Equal(f1.UpFractal, f2.UpFractal);
|
||||
Assert.Equal(f1.DownFractal, f2.DownFractal);
|
||||
}
|
||||
}
|
||||
|
||||
// -- G) Span API Tests --------------------------------------------------------
|
||||
public sealed class FractalsSpanTests
|
||||
{
|
||||
[Fact]
|
||||
public void Batch_Span_MismatchedLengths_Throws()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Fractals.Batch(new double[10], new double[5], new double[10], new double[10]));
|
||||
Assert.Equal("high", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_OutputTooShort_Throws()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Fractals.Batch(new double[10], new double[10], new double[5], new double[10]));
|
||||
Assert.Equal("upOutput", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_DownOutputTooShort_Throws()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Fractals.Batch(new double[10], new double[10], new double[10], new double[5]));
|
||||
Assert.Equal("downOutput", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_Empty_NoException()
|
||||
{
|
||||
var ex = Record.Exception(() =>
|
||||
Fractals.Batch(ReadOnlySpan<double>.Empty, ReadOnlySpan<double>.Empty,
|
||||
Span<double>.Empty, Span<double>.Empty));
|
||||
Assert.Null(ex);
|
||||
}
|
||||
}
|
||||
|
||||
// -- H) Event / Chainability -------------------------------------------------
|
||||
public sealed class FractalsEventTests
|
||||
{
|
||||
[Fact]
|
||||
public void Pub_FiresOnUpdate()
|
||||
{
|
||||
var f = new Fractals();
|
||||
int fireCount = 0;
|
||||
|
||||
f.Pub += (object? _, in TValueEventArgs _e) => { fireCount++; };
|
||||
|
||||
_ = f.Update(new TBar(DateTime.UtcNow, 97, 100, 95, 98, 1000));
|
||||
|
||||
Assert.Equal(1, fireCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Pub_FiresOnEachUpdate()
|
||||
{
|
||||
var f = new Fractals();
|
||||
int fireCount = 0;
|
||||
|
||||
f.Pub += (object? _, in TValueEventArgs _e) => { fireCount++; };
|
||||
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
double price = 100.0 + i;
|
||||
_ = f.Update(new TBar(DateTime.UtcNow.AddMinutes(i), price, price + 2, price - 2, price + 1, 1000));
|
||||
}
|
||||
|
||||
Assert.Equal(5, fireCount);
|
||||
}
|
||||
}
|
||||
|
||||
// -- I) Prime Tests -----------------------------------------------------------
|
||||
public sealed class FractalsPrimeTests
|
||||
{
|
||||
[Fact]
|
||||
public void Prime_TBarSeries_SetsState()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.20, seed: 42);
|
||||
var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var f = new Fractals();
|
||||
f.Prime(bars);
|
||||
|
||||
Assert.True(f.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Prime_EmptySource_NoException()
|
||||
{
|
||||
var f = new Fractals();
|
||||
var bars = new TBarSeries();
|
||||
|
||||
var ex = Record.Exception(() => f.Prime(bars));
|
||||
Assert.Null(ex);
|
||||
Assert.False(f.IsHot);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,268 @@
|
||||
// FRACTALS Validation Tests - Williams Fractals
|
||||
// Cross-validated against Skender.Stock.Indicators GetFractal()
|
||||
//
|
||||
// Important alignment notes:
|
||||
// - Skender reports fractal at the bar where the fractal occurs (bar[2] in our terms)
|
||||
// - Our streaming indicator reports at the current bar (bar[0]) when detection happens
|
||||
// - Therefore: our value at index i corresponds to Skender's value at index (i-2)
|
||||
// - Skender naming: FractalBear = high point (resistance) = our UpFractal
|
||||
// FractalBull = low point (support) = our DownFractal
|
||||
|
||||
using Skender.Stock.Indicators;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class FractalsValidationTests
|
||||
{
|
||||
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 UpFractal (= Skender FractalBear) -----------------
|
||||
|
||||
[Fact]
|
||||
public void StreamingMatchesSkender_UpFractal()
|
||||
{
|
||||
var _data = new ValidationTestData();
|
||||
|
||||
// Skender: FractalBear = high point = our UpFractal
|
||||
var skenderResults = _data.SkenderQuotes
|
||||
.GetFractal()
|
||||
.ToList();
|
||||
|
||||
// QuanTAlib streaming
|
||||
var f = new Fractals();
|
||||
var ourUpValues = new double[_data.Bars.Count];
|
||||
for (int i = 0; i < _data.Bars.Count; i++)
|
||||
{
|
||||
_ = f.Update(_data.Bars[i], isNew: true);
|
||||
ourUpValues[i] = f.UpFractal;
|
||||
}
|
||||
|
||||
// Compare with 2-bar offset: our value at i matches Skender at i-2
|
||||
int matched = 0;
|
||||
for (int i = 4; i < _data.Bars.Count; i++)
|
||||
{
|
||||
int skenderIdx = i - 2;
|
||||
if (skenderIdx < 0 || skenderIdx >= skenderResults.Count)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
decimal? skenderBear = skenderResults[skenderIdx].FractalBear;
|
||||
bool skenderIsNull = !skenderBear.HasValue;
|
||||
bool ourIsNaN = double.IsNaN(ourUpValues[i]);
|
||||
|
||||
if (skenderIsNull && ourIsNaN)
|
||||
{
|
||||
matched++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!skenderIsNull && !ourIsNaN)
|
||||
{
|
||||
Assert.Equal((double)skenderBear!.Value, ourUpValues[i], precision: 6);
|
||||
matched++;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.True(matched > 0, "Should have matched at least one warm value");
|
||||
_data.Dispose();
|
||||
}
|
||||
|
||||
// -- Cross-library: Skender DownFractal (= Skender FractalBull) ---------------
|
||||
|
||||
[Fact]
|
||||
public void StreamingMatchesSkender_DownFractal()
|
||||
{
|
||||
var _data = new ValidationTestData();
|
||||
|
||||
// Skender: FractalBull = low point = our DownFractal
|
||||
var skenderResults = _data.SkenderQuotes
|
||||
.GetFractal()
|
||||
.ToList();
|
||||
|
||||
// QuanTAlib streaming
|
||||
var f = new Fractals();
|
||||
var ourDownValues = new double[_data.Bars.Count];
|
||||
for (int i = 0; i < _data.Bars.Count; i++)
|
||||
{
|
||||
_ = f.Update(_data.Bars[i], isNew: true);
|
||||
ourDownValues[i] = f.DownFractal;
|
||||
}
|
||||
|
||||
// Compare with 2-bar offset: our value at i matches Skender at i-2
|
||||
int matched = 0;
|
||||
for (int i = 4; i < _data.Bars.Count; i++)
|
||||
{
|
||||
int skenderIdx = i - 2;
|
||||
if (skenderIdx < 0 || skenderIdx >= skenderResults.Count)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
decimal? skenderBull = skenderResults[skenderIdx].FractalBull;
|
||||
bool skenderIsNull = !skenderBull.HasValue;
|
||||
bool ourIsNaN = double.IsNaN(ourDownValues[i]);
|
||||
|
||||
if (skenderIsNull && ourIsNaN)
|
||||
{
|
||||
matched++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!skenderIsNull && !ourIsNaN)
|
||||
{
|
||||
Assert.Equal((double)skenderBull!.Value, ourDownValues[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_UpFractal()
|
||||
{
|
||||
var bars = CreateGbmBars();
|
||||
|
||||
// Streaming
|
||||
var streaming = new Fractals();
|
||||
var streamUp = new double[bars.Count];
|
||||
for (int i = 0; i < bars.Count; i++)
|
||||
{
|
||||
_ = streaming.Update(bars[i], isNew: true);
|
||||
streamUp[i] = streaming.UpFractal;
|
||||
}
|
||||
|
||||
// Batch
|
||||
var batchResults = Fractals.Batch(bars);
|
||||
|
||||
for (int i = 4; i < bars.Count; i++)
|
||||
{
|
||||
if (double.IsNaN(streamUp[i]))
|
||||
{
|
||||
Assert.True(double.IsNaN(batchResults[i].Value), $"Mismatch at {i}: streaming=NaN, batch={batchResults[i].Value}");
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal(streamUp[i], batchResults[i].Value, precision: 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -- Self-Consistency: Streaming == Span ---------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void StreamingMatchesSpan_BothFractals()
|
||||
{
|
||||
var bars = CreateGbmBars();
|
||||
|
||||
// Streaming
|
||||
var streaming = new Fractals();
|
||||
var streamUp = new double[bars.Count];
|
||||
var streamDown = new double[bars.Count];
|
||||
for (int i = 0; i < bars.Count; i++)
|
||||
{
|
||||
_ = streaming.Update(bars[i], isNew: true);
|
||||
streamUp[i] = streaming.UpFractal;
|
||||
streamDown[i] = streaming.DownFractal;
|
||||
}
|
||||
|
||||
// Span
|
||||
var spanUp = new double[bars.Count];
|
||||
var spanDown = new double[bars.Count];
|
||||
Fractals.Batch(bars.HighValues, bars.LowValues, spanUp, spanDown);
|
||||
|
||||
for (int i = 4; i < bars.Count; i++)
|
||||
{
|
||||
if (double.IsNaN(streamUp[i]))
|
||||
{
|
||||
Assert.True(double.IsNaN(spanUp[i]));
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal(streamUp[i], spanUp[i], precision: 10);
|
||||
}
|
||||
|
||||
if (double.IsNaN(streamDown[i]))
|
||||
{
|
||||
Assert.True(double.IsNaN(spanDown[i]));
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal(streamDown[i], spanDown[i], precision: 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -- Determinism ---------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void SameInput_ProducesSameOutput()
|
||||
{
|
||||
var bars = CreateGbmBars(count: 200, seed: 123);
|
||||
|
||||
var f1 = new Fractals();
|
||||
var f2 = new Fractals();
|
||||
|
||||
for (int i = 0; i < bars.Count; i++)
|
||||
{
|
||||
_ = f1.Update(bars[i], isNew: true);
|
||||
_ = f2.Update(bars[i], isNew: true);
|
||||
}
|
||||
|
||||
Assert.Equal(f1.UpFractal, f2.UpFractal);
|
||||
Assert.Equal(f1.DownFractal, f2.DownFractal);
|
||||
}
|
||||
|
||||
// -- Calculate Returns Valid Indicator -----------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void Calculate_ReturnsValidIndicatorAndResults()
|
||||
{
|
||||
var bars = CreateGbmBars(count: 100);
|
||||
|
||||
var (results, indicator) = Fractals.Calculate(bars);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.Equal(bars.Count, results.Count);
|
||||
Assert.True(indicator.IsHot);
|
||||
}
|
||||
|
||||
// -- BatchDual Returns Both Fractals ------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void BatchDual_ReturnsBothSeries()
|
||||
{
|
||||
var bars = CreateGbmBars(count: 100);
|
||||
|
||||
var (upSeries, downSeries) = Fractals.BatchDual(bars);
|
||||
|
||||
Assert.Equal(bars.Count, upSeries.Count);
|
||||
Assert.Equal(bars.Count, downSeries.Count);
|
||||
|
||||
// At least some fractals should be detected in 100 bars
|
||||
bool hasUp = false;
|
||||
bool hasDown = false;
|
||||
for (int i = 0; i < upSeries.Count; i++)
|
||||
{
|
||||
if (double.IsFinite(upSeries[i].Value))
|
||||
{
|
||||
hasUp = true;
|
||||
}
|
||||
if (double.IsFinite(downSeries[i].Value))
|
||||
{
|
||||
hasDown = true;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.True(hasUp, "Should detect at least one up fractal in 100 bars");
|
||||
Assert.True(hasDown, "Should detect at least one down fractal in 100 bars");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user