mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-21 20:18:05 +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,609 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class CwtTests
|
||||
{
|
||||
private const double Tolerance = 1e-10;
|
||||
|
||||
// ─── A) Constructor validation ────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Constructor_DefaultParameters_SetsProperties()
|
||||
{
|
||||
var indicator = new Cwt();
|
||||
Assert.Equal("Cwt(10,6)", indicator.Name);
|
||||
Assert.False(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_CustomParameters_SetsName()
|
||||
{
|
||||
var indicator = new Cwt(scale: 20.0, omega0: 5.0);
|
||||
Assert.Equal("Cwt(20,5)", indicator.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroScale_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Cwt(scale: 0.0));
|
||||
Assert.Equal("scale", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativeScale_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Cwt(scale: -1.0));
|
||||
Assert.Equal("scale", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroOmega_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Cwt(omega0: 0.0));
|
||||
Assert.Equal("omega0", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativeOmega_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Cwt(omega0: -6.0));
|
||||
Assert.Equal("omega0", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WarmupPeriod_IsWindowSize()
|
||||
{
|
||||
// windowSize = 2*round(3*scale)+1 = 2*30+1 = 61 for scale=10
|
||||
var indicator = new Cwt(scale: 10.0);
|
||||
Assert.Equal(61, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_SmallScale_CorrectWarmup()
|
||||
{
|
||||
// scale=1: halfWindow=round(3)=3, windowSize=7
|
||||
var indicator = new Cwt(scale: 1.0);
|
||||
Assert.Equal(7, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
// ─── B) Basic calculation ─────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsValidTValue()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
var input = new TValue(time, 100.0);
|
||||
var result = indicator.Update(input);
|
||||
Assert.Equal(input.Time, result.Time);
|
||||
Assert.True(double.IsFinite(result.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_Output_IsNonNegative()
|
||||
{
|
||||
// CWT magnitude is always >= 0
|
||||
var indicator = new Cwt(scale: 3.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70001);
|
||||
var bars = gbm.Fetch(windowSize + 10, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
for (int i = 0; i < bars.Close.Count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
Assert.True(indicator.Last.Value >= 0.0,
|
||||
$"CWT magnitude must be >= 0, got {indicator.Last.Value} at bar {i}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Last_IsAccessible_AfterUpdate()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
indicator.Update(new TValue(time, 50.0));
|
||||
Assert.NotEqual(default, indicator.Last);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Name_Accessible()
|
||||
{
|
||||
var indicator = new Cwt(scale: 5.0, omega0: 6.0);
|
||||
Assert.NotNull(indicator.Name);
|
||||
Assert.Contains("Cwt", indicator.Name, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
// ─── C) State + bar correction ────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNewTrue_AdvancesState()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70002);
|
||||
var bars = gbm.Fetch(windowSize + 5, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
for (int i = 0; i < windowSize; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
double before = indicator.Last.Value;
|
||||
indicator.Update(new TValue(time.AddMinutes(windowSize), 9999.0), true);
|
||||
double after = indicator.Last.Value;
|
||||
|
||||
// Extreme new value should change the output
|
||||
Assert.True(double.IsFinite(after));
|
||||
// Values may differ (9999 vs GBM prices)
|
||||
_ = before; // consumed
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNewFalse_RewritesLastBar()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70003);
|
||||
var bars = gbm.Fetch(windowSize + 2, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
// Fill to warmup
|
||||
for (int i = 0; i < windowSize; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
// New bar with extreme value A
|
||||
indicator.Update(new TValue(time.AddMinutes(windowSize), 9999.0), true);
|
||||
double valueA = indicator.Last.Value;
|
||||
|
||||
// Correct same bar with a different extreme value B
|
||||
indicator.Update(new TValue(time.AddMinutes(windowSize), 0.001), false);
|
||||
double valueB = indicator.Last.Value;
|
||||
|
||||
Assert.NotEqual(valueA, valueB, 1e-6);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IterativeCorrection_RestoresState()
|
||||
{
|
||||
var time = DateTime.UtcNow;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70004);
|
||||
int count = 30;
|
||||
var bars = gbm.Fetch(count, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
// Streaming without corrections
|
||||
var straight = new Cwt(scale: 2.0);
|
||||
for (int i = 0; i < bars.Close.Count; i++)
|
||||
{
|
||||
straight.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
double finalStraight = straight.Last.Value;
|
||||
|
||||
// With corrections (wrong → corrected)
|
||||
var corrected = new Cwt(scale: 2.0);
|
||||
for (int i = 0; i < bars.Close.Count; i++)
|
||||
{
|
||||
corrected.Update(new TValue(bars.Close[i].Time, 999.0), true);
|
||||
corrected.Update(bars.Close[i], false);
|
||||
}
|
||||
|
||||
Assert.Equal(finalStraight, corrected.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70005);
|
||||
var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
for (int i = 0; i < bars.Close.Count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
|
||||
indicator.Reset();
|
||||
|
||||
Assert.False(indicator.IsHot);
|
||||
Assert.Equal(default, indicator.Last);
|
||||
}
|
||||
|
||||
// ─── D) Warmup / convergence ──────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void IsHot_FlipsAtWindowSize()
|
||||
{
|
||||
// scale=2: halfWindow=round(6)=6, windowSize=13
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
for (int i = 0; i < windowSize - 1; i++)
|
||||
{
|
||||
indicator.Update(new TValue(time.AddMinutes(i), 100.0 + i));
|
||||
Assert.False(indicator.IsHot, $"Should not be hot at bar {i + 1}");
|
||||
}
|
||||
|
||||
indicator.Update(new TValue(time.AddMinutes(windowSize - 1), 100.0 + windowSize));
|
||||
Assert.True(indicator.IsHot, "Should be hot after windowSize bars");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WarmupPeriod_ScaleDependent()
|
||||
{
|
||||
// scale=5: halfWindow=round(15)=15, windowSize=31
|
||||
var ind5 = new Cwt(scale: 5.0);
|
||||
Assert.Equal(31, ind5.WarmupPeriod);
|
||||
|
||||
// scale=0.5: halfWindow=round(1.5)=2, windowSize=5
|
||||
var ind05 = new Cwt(scale: 0.5);
|
||||
Assert.Equal(5, ind05.WarmupPeriod);
|
||||
}
|
||||
|
||||
// ─── E) Robustness ────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_NaN_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
// Fill to hot
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70006);
|
||||
var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
for (int i = 0; i < windowSize; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
double before = indicator.Last.Value;
|
||||
|
||||
indicator.Update(new TValue(time.AddMinutes(windowSize), double.NaN));
|
||||
Assert.Equal(before, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_PositiveInfinity_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70007);
|
||||
var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
for (int i = 0; i < windowSize; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
double before = indicator.Last.Value;
|
||||
indicator.Update(new TValue(time.AddMinutes(windowSize), double.PositiveInfinity));
|
||||
Assert.Equal(before, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NegativeInfinity_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70008);
|
||||
var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
for (int i = 0; i < windowSize; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
double before = indicator.Last.Value;
|
||||
indicator.Update(new TValue(time.AddMinutes(windowSize), double.NegativeInfinity));
|
||||
Assert.Equal(before, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_BatchNaN_AlwaysFinite()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
double[] prices = { 100.0, double.NaN, 102.0, double.NaN, 98.0, 105.0, 103.0, 99.0, 101.0, 104.0, 97.0, 106.0, 108.0 };
|
||||
for (int i = 0; i < prices.Length; i++)
|
||||
{
|
||||
var result = indicator.Update(new TValue(time.AddMinutes(i), prices[i]));
|
||||
Assert.True(double.IsFinite(result.Value), $"Output must be finite at {i}, got {result.Value}");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── F) Consistency: batch == streaming == span == eventing ──────────────
|
||||
|
||||
[Fact]
|
||||
public void AllModes_ConsistencyCheck()
|
||||
{
|
||||
int scale = 3;
|
||||
int count = 80;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70009);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
// Streaming
|
||||
var streaming = new Cwt(scale);
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streaming.Update(source[i]);
|
||||
}
|
||||
|
||||
// Batch (TSeries)
|
||||
var batch = Cwt.Batch(source, scale);
|
||||
|
||||
// Span
|
||||
var rawValues = new double[source.Count];
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
rawValues[i] = source[i].Value;
|
||||
}
|
||||
|
||||
var spanOutput = new double[source.Count];
|
||||
Cwt.Batch(rawValues, spanOutput, scale);
|
||||
|
||||
// Eventing
|
||||
var eventResults = new List<double>();
|
||||
var eventSource = new TSeries();
|
||||
var eventIndicator = new Cwt(eventSource, scale);
|
||||
eventIndicator.Pub += (object? s, in TValueEventArgs e) => eventResults.Add(e.Value.Value);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
eventSource.Add(source[i], true);
|
||||
}
|
||||
|
||||
// Verify last value matches all modes
|
||||
double streamingLast = streaming.Last.Value;
|
||||
double batchLast = batch[source.Count - 1].Value;
|
||||
double spanLast = spanOutput[source.Count - 1];
|
||||
double eventLast = eventResults[^1];
|
||||
|
||||
Assert.Equal(streamingLast, batchLast, Tolerance);
|
||||
Assert.Equal(streamingLast, spanLast, Tolerance);
|
||||
Assert.Equal(streamingLast, eventLast, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Streaming_VsBatch_AllValues_Match()
|
||||
{
|
||||
int count = 80;
|
||||
double scale = 2.0;
|
||||
var gbm = new GBM(startPrice: 50, mu: 0.0, sigma: 0.3, seed: 70010);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
var streaming = new Cwt(scale);
|
||||
var streamingVals = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
streaming.Update(source[i]);
|
||||
streamingVals[i] = streaming.Last.Value;
|
||||
}
|
||||
|
||||
var batch = Cwt.Batch(source, scale);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Assert.Equal(streamingVals[i], batch[i].Value, Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── G) Span API tests ────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_EmptySource_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Cwt.Batch([], Array.Empty<double>()));
|
||||
Assert.Equal("source", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_OutputTooShort_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[2];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Cwt.Batch(src, dst));
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_InvalidScale_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Cwt.Batch(src, dst, scale: 0.0));
|
||||
Assert.Equal("scale", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_InvalidOmega_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Cwt.Batch(src, dst, omega0: -1.0));
|
||||
Assert.Equal("omega0", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_OutputIsNonNegative()
|
||||
{
|
||||
int count = 100;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70011);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
double[] src = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
src[i] = bars.Close[i].Value;
|
||||
}
|
||||
|
||||
double[] dst = new double[count];
|
||||
Cwt.Batch(src, dst, scale: 3.0);
|
||||
|
||||
foreach (double v in dst)
|
||||
{
|
||||
Assert.True(v >= 0.0, $"CWT magnitude {v} must be >= 0");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_HandlesNaN()
|
||||
{
|
||||
int windowSize = 7; // scale=1: 2*3+1=7
|
||||
double[] src = new double[windowSize + 5];
|
||||
for (int i = 0; i < src.Length; i++)
|
||||
{
|
||||
src[i] = 100.0 + i;
|
||||
}
|
||||
|
||||
src[3] = double.NaN;
|
||||
double[] dst = new double[src.Length];
|
||||
Cwt.Batch(src, dst, scale: 1.0);
|
||||
|
||||
foreach (double v in dst)
|
||||
{
|
||||
Assert.True(double.IsFinite(v), $"Span output should always be finite, got {v}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_NoStackOverflow_LargeScale()
|
||||
{
|
||||
// scale=40: halfWindow=120, windowSize=241 → uses ArrayPool (>128)
|
||||
int count = 500;
|
||||
double[] src = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
src[i] = 100.0 + Math.Sin(i * 0.1) * 10.0;
|
||||
}
|
||||
|
||||
double[] dst = new double[count];
|
||||
// Should not throw StackOverflowException
|
||||
Cwt.Batch(src, dst, scale: 40.0);
|
||||
|
||||
foreach (double v in dst)
|
||||
{
|
||||
Assert.True(double.IsFinite(v));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_MatchesStreaming()
|
||||
{
|
||||
int count = 60;
|
||||
double scale = 2.0;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.25, seed: 70012);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
double[] src = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
src[i] = bars.Close[i].Value;
|
||||
}
|
||||
|
||||
double[] spanOut = new double[count];
|
||||
Cwt.Batch(src, spanOut, scale: scale);
|
||||
|
||||
var streaming = new Cwt(scale);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
streaming.Update(bars.Close[i]);
|
||||
Assert.Equal(streaming.Last.Value, spanOut[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── H) Chainability ──────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Pub_EventFires()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
int count = 0;
|
||||
indicator.Pub += (object? sender, in TValueEventArgs args) => count++;
|
||||
|
||||
var time = DateTime.UtcNow;
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
indicator.Update(new TValue(time.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
Assert.Equal(5, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Chaining_Constructor_Works()
|
||||
{
|
||||
double scale = 2.0;
|
||||
var source = new TSeries();
|
||||
var indicator = new Cwt(source, scale);
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
|
||||
var time = DateTime.UtcNow;
|
||||
for (int i = 0; i < windowSize; i++)
|
||||
{
|
||||
source.Add(new TValue(time.AddMinutes(i), 100.0 + i), true);
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
Assert.True(indicator.Last.Value >= 0.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Pub_EventValue_MatchesLast()
|
||||
{
|
||||
var indicator = new Cwt(scale: 2.0);
|
||||
TValue? lastEvent = null;
|
||||
indicator.Pub += (object? s, in TValueEventArgs e) => lastEvent = e.Value;
|
||||
|
||||
var time = DateTime.UtcNow;
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70013);
|
||||
var bars = gbm.Fetch(windowSize + 2, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
for (int i = 0; i < bars.Close.Count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
Assert.NotNull(lastEvent);
|
||||
Assert.Equal(indicator.Last.Value, lastEvent.Value.Value, Tolerance);
|
||||
}
|
||||
|
||||
// ─── Additional: static Calculate method ─────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Calculate_StaticMethod_ReturnsTuple()
|
||||
{
|
||||
int count = 80;
|
||||
double scale = 3.0;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70014);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var (results, instance) = Cwt.Calculate(bars.Close, scale);
|
||||
|
||||
Assert.Equal(count, results.Count);
|
||||
Assert.Equal(results[^1].Value, instance.Last.Value, Tolerance);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// CWT validation tests — verifies known wavelet responses against analytical results.
|
||||
/// Since no external reference library implements CWT, we validate against:
|
||||
/// 1. Zero-input → zero output (linearity)
|
||||
/// 2. Constant input → near-zero output (wavelets have zero mean, so DC is rejected)
|
||||
/// 3. Sinusoidal resonance: CWT at matching scale produces larger magnitude than at non-matching scale
|
||||
/// 4. Output non-negativity (magnitude is always >= 0)
|
||||
/// 5. Determinism (same input always produces same output)
|
||||
/// 6. Batch vs streaming consistency
|
||||
/// </summary>
|
||||
public class CwtValidationTests
|
||||
{
|
||||
private const double Tolerance = 1e-10;
|
||||
private const double LooseTolerance = 1e-6;
|
||||
|
||||
// ─── Zero-mean property (DC rejection) ───────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_ConstantInput_NearZero()
|
||||
{
|
||||
// Morlet wavelet has zero mean → convolution with constant signal ≈ 0
|
||||
// (not exactly 0 due to finite window, but very small relative to signal amplitude)
|
||||
double scale = 5.0;
|
||||
var indicator = new Cwt(scale);
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Feed constant value = 100.0 for full window + extra bars
|
||||
for (int i = 0; i < windowSize + 10; i++)
|
||||
{
|
||||
indicator.Update(new TValue(time.AddSeconds(i), 100.0));
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
// Output should be very small relative to input amplitude (100.0)
|
||||
// Due to finite window truncation, Morlet real part sums are not exactly 0,
|
||||
// but the value should be negligible compared to signal energy.
|
||||
Assert.True(indicator.Last.Value < 5.0,
|
||||
$"Constant input should give near-zero CWT, got {indicator.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Cwt_ZeroInput_OutputIsZero()
|
||||
{
|
||||
// Zero signal → zero output (by linearity)
|
||||
double scale = 5.0;
|
||||
var indicator = new Cwt(scale);
|
||||
int windowSize = indicator.WarmupPeriod;
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < windowSize + 5; i++)
|
||||
{
|
||||
indicator.Update(new TValue(time.AddSeconds(i), 0.0));
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
Assert.Equal(0.0, indicator.Last.Value, LooseTolerance);
|
||||
}
|
||||
|
||||
// ─── Resonance: matching scale produces peak response ────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_SinusoidalResonance_MatchingScaleHigher()
|
||||
{
|
||||
// A pure sine wave with period P should give maximum CWT magnitude at
|
||||
// scale s ≈ P*omega0/(2π). With omega0=6: s ≈ P/1.047
|
||||
// We test: scale_match gives strictly larger magnitude than scale_mismatch
|
||||
// on the same sinusoidal input.
|
||||
|
||||
double omega0 = 6.0;
|
||||
double targetPeriod = 10.0; // 10-bar sine wave
|
||||
double matchingScale = targetPeriod * omega0 / (2.0 * Math.PI); // ≈ 9.55
|
||||
double mismatchScale = 2.0; // very different scale
|
||||
|
||||
int count = 300;
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var matchIndicator = new Cwt(matchingScale, omega0);
|
||||
var mismatchIndicator = new Cwt(mismatchScale, omega0);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
double signal = Math.Sin(2.0 * Math.PI * i / targetPeriod);
|
||||
var tv = new TValue(time.AddSeconds(i), signal);
|
||||
matchIndicator.Update(tv);
|
||||
mismatchIndicator.Update(tv);
|
||||
}
|
||||
|
||||
Assert.True(matchIndicator.IsHot);
|
||||
Assert.True(mismatchIndicator.IsHot);
|
||||
|
||||
// Average magnitude over last half to smooth fluctuations
|
||||
// Reset and recompute for clean average
|
||||
var matchIndicator2 = new Cwt(matchingScale, omega0);
|
||||
var mismatchIndicator2 = new Cwt(mismatchScale, omega0);
|
||||
|
||||
double sumMatch = 0.0, sumMismatch = 0.0;
|
||||
int nMatch = 0, nMismatch = 0;
|
||||
int halfCount = count / 2;
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
double signal = Math.Sin(2.0 * Math.PI * i / targetPeriod);
|
||||
var tv = new TValue(time.AddSeconds(i), signal);
|
||||
matchIndicator2.Update(tv);
|
||||
mismatchIndicator2.Update(tv);
|
||||
|
||||
if (i >= halfCount)
|
||||
{
|
||||
if (matchIndicator2.IsHot)
|
||||
{
|
||||
sumMatch += matchIndicator2.Last.Value;
|
||||
nMatch++;
|
||||
}
|
||||
|
||||
if (mismatchIndicator2.IsHot)
|
||||
{
|
||||
sumMismatch += mismatchIndicator2.Last.Value;
|
||||
nMismatch++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
double avgMatch = nMatch > 0 ? sumMatch / nMatch : 0.0;
|
||||
double avgMismatch = nMismatch > 0 ? sumMismatch / nMismatch : 0.0;
|
||||
|
||||
Assert.True(avgMatch > avgMismatch,
|
||||
$"Matching scale ({matchingScale:F2}) avg={avgMatch:F4} should exceed " +
|
||||
$"mismatch scale ({mismatchScale:F2}) avg={avgMismatch:F4}");
|
||||
}
|
||||
|
||||
// ─── Non-negativity invariant ─────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_OutputAlwaysNonNegative_GbmData()
|
||||
{
|
||||
int count = 300;
|
||||
double scale = 8.0;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 72001);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Cwt(scale);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
Assert.True(indicator.Last.Value >= 0.0,
|
||||
$"CWT magnitude negative at bar {i}: {indicator.Last.Value}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Cwt_OutputAlwaysNonNegative_SpanBatch()
|
||||
{
|
||||
int count = 200;
|
||||
double scale = 5.0;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.25, seed: 72002);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
double[] src = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
src[i] = bars.Close[i].Value;
|
||||
}
|
||||
|
||||
double[] dst = new double[count];
|
||||
Cwt.Batch(src, dst, scale);
|
||||
|
||||
foreach (double v in dst)
|
||||
{
|
||||
Assert.True(v >= 0.0, $"Span CWT magnitude {v} must be >= 0");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Determinism ──────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_Deterministic_SameInput_SameOutput()
|
||||
{
|
||||
int count = 100;
|
||||
double scale = 6.0;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72003);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var ind1 = new Cwt(scale);
|
||||
var ind2 = new Cwt(scale);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
ind1.Update(bars.Close[i]);
|
||||
ind2.Update(bars.Close[i]);
|
||||
Assert.Equal(ind1.Last.Value, ind2.Last.Value, Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Scale effect: larger scale → lower frequency ─────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_DifferentScales_DifferentOutput()
|
||||
{
|
||||
int count = 100;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72004);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var ind3 = new Cwt(scale: 3.0);
|
||||
var ind10 = new Cwt(scale: 10.0);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
ind3.Update(bars.Close[i]);
|
||||
ind10.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
// Different scales must produce different outputs (unless degenerate input)
|
||||
Assert.NotEqual(ind3.Last.Value, ind10.Last.Value, 1e-6);
|
||||
}
|
||||
|
||||
// ─── Batch vs streaming full-array consistency ───────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_Batch_MatchesStreaming_AllValues()
|
||||
{
|
||||
int count = 150;
|
||||
double scale = 4.0;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.25, seed: 72005);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
double[] rawValues = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
rawValues[i] = bars.Close[i].Value;
|
||||
}
|
||||
|
||||
var tseriesResult = Cwt.Batch(bars.Close, scale);
|
||||
double[] spanResult = new double[count];
|
||||
Cwt.Batch(rawValues, spanResult, scale);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Assert.Equal(tseriesResult[i].Value, spanResult[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Large dataset: stable ────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_LargeDataset_Stable()
|
||||
{
|
||||
int count = 2000;
|
||||
double scale = 10.0;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72006);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Cwt(scale);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
double v = indicator.Last.Value;
|
||||
Assert.True(double.IsFinite(v) && v >= 0.0,
|
||||
$"Invalid output {v} at bar {i}");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Period=1 trivial: single sample → zero (warmup) ─────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cwt_SingleSampleBeforeWarmup_OutputZero()
|
||||
{
|
||||
var indicator = new Cwt(scale: 5.0);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Only one update: should NOT be hot
|
||||
indicator.Update(new TValue(time, 100.0));
|
||||
|
||||
Assert.False(indicator.IsHot);
|
||||
Assert.Equal(0.0, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user