mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-24 05:28: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,650 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class NormdistTests
|
||||
{
|
||||
private const double Tolerance = 1e-10;
|
||||
|
||||
// ─── A) Constructor validation ────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Constructor_DefaultParameters_SetsProperties()
|
||||
{
|
||||
var indicator = new Normdist();
|
||||
Assert.Equal("Normdist(0.00,1.00,14)", indicator.Name);
|
||||
Assert.Equal(14, indicator.WarmupPeriod);
|
||||
Assert.False(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_CustomParameters_SetsName()
|
||||
{
|
||||
var indicator = new Normdist(mu: 0.5, sigma: 2.0, period: 20);
|
||||
Assert.Equal("Normdist(0.50,2.00,20)", indicator.Name);
|
||||
Assert.Equal(20, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroSigma_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Normdist(sigma: 0.0));
|
||||
Assert.Equal("sigma", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativeSigma_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Normdist(sigma: -1.0));
|
||||
Assert.Equal("sigma", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_PeriodOne_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Normdist(period: 1));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroPeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Normdist(period: 0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativePeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Normdist(period: -1));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
// ─── B) Basic calculation ─────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsValidTValue()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
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_OutputInRange()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
Assert.True(indicator.Last.Value >= 0.0, "Output must be >= 0");
|
||||
Assert.True(indicator.Last.Value <= 1.0, "Output must be <= 1");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Last_IsAccessible_AfterUpdate()
|
||||
{
|
||||
var indicator = new Normdist(period: 3);
|
||||
var time = DateTime.UtcNow;
|
||||
indicator.Update(new TValue(time, 50.0));
|
||||
Assert.NotEqual(default, indicator.Last);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_Property_ReflectsWarmup()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
indicator.Update(new TValue(time.AddMinutes(i), 100.0 + i));
|
||||
Assert.False(indicator.IsHot);
|
||||
}
|
||||
|
||||
indicator.Update(new TValue(time.AddMinutes(4), 104.0));
|
||||
Assert.True(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_AtRollingMean_ReturnsNearHalf()
|
||||
{
|
||||
// When current value equals rolling mean (with mu=0), z=0 → Φ(0)=0.5
|
||||
var indicator = new Normdist(mu: 0.0, sigma: 1.0, period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
// Feed symmetric data; last bar equals the mean
|
||||
double[] prices = { 100.0, 102.0, 104.0, 106.0, 103.0 }; // mean = 103.0
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
// 103 is the mean, so z=0 → Φ(0)=0.5 (approximately, since stddev>0)
|
||||
// With stddev > 0 and z=0: CDF = 0.5 exactly (erf(0)=0)
|
||||
Assert.InRange(indicator.Last.Value, 0.0, 1.0);
|
||||
}
|
||||
|
||||
// ─── C) State + bar correction ────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNewTrue_AdvancesState()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
double first = indicator.Last.Value;
|
||||
indicator.Update(new TValue(time, 110.0));
|
||||
double second = indicator.Last.Value;
|
||||
|
||||
Assert.NotEqual(first, second, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNewFalse_RewritesLastBar()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
// New bar with value A
|
||||
indicator.Update(new TValue(time, 110.0), true);
|
||||
double valueA = indicator.Last.Value;
|
||||
|
||||
// Correct same bar with very different value B
|
||||
indicator.Update(new TValue(time, 90.0), false);
|
||||
double valueB = indicator.Last.Value;
|
||||
|
||||
Assert.NotEqual(valueA, valueB, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IterativeCorrection_RestoresState()
|
||||
{
|
||||
var time = DateTime.UtcNow;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72001);
|
||||
var bars = gbm.Fetch(20, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
// Streaming without corrections
|
||||
var straight = new Normdist(period: 5);
|
||||
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 Normdist(period: 5);
|
||||
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 Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
|
||||
indicator.Reset();
|
||||
|
||||
Assert.False(indicator.IsHot);
|
||||
Assert.Equal(default, indicator.Last);
|
||||
}
|
||||
|
||||
// ─── D) Warmup / convergence ──────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void IsHot_FlipsAtPeriod()
|
||||
{
|
||||
int period = 10;
|
||||
var indicator = new Normdist(period: period);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < period - 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(period - 1), 100.0 + period));
|
||||
Assert.True(indicator.IsHot, "Should be hot after period bars");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WarmupPeriod_EqualsConstructorPeriod()
|
||||
{
|
||||
var indicator = new Normdist(period: 25);
|
||||
Assert.Equal(25, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
// ─── E) Robustness ────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_NaN_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
double before = indicator.Last.Value;
|
||||
|
||||
indicator.Update(new TValue(time, double.NaN));
|
||||
Assert.Equal(before, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_PositiveInfinity_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
double before = indicator.Last.Value;
|
||||
indicator.Update(new TValue(time, double.PositiveInfinity));
|
||||
Assert.Equal(before, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NegativeInfinity_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
double before = indicator.Last.Value;
|
||||
indicator.Update(new TValue(time, double.NegativeInfinity));
|
||||
Assert.Equal(before, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_BatchNaN_Stable()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
double[] prices = { 100.0, double.NaN, 102.0, double.NaN, 98.0, 105.0, 103.0 };
|
||||
foreach (var p in prices)
|
||||
{
|
||||
var result = indicator.Update(new TValue(time, p));
|
||||
Assert.True(double.IsFinite(result.Value), "Output must always be finite");
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_FlatValues_ReturnsHalf()
|
||||
{
|
||||
// When all values identical, stddev=0 → z=0 → CDF = 0.5
|
||||
var indicator = new Normdist(mu: 0.0, sigma: 1.0, period: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(new TValue(time.AddMinutes(i), 100.0));
|
||||
}
|
||||
|
||||
Assert.Equal(0.5, indicator.Last.Value, 1e-6);
|
||||
}
|
||||
|
||||
// ─── F) Consistency: batch == streaming == span == eventing ──────────────
|
||||
|
||||
[Fact]
|
||||
public void AllModes_ConsistencyCheck()
|
||||
{
|
||||
int count = 100;
|
||||
int period = 20;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72002);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
// Streaming
|
||||
var streaming = new Normdist(period: period);
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streaming.Update(source[i]);
|
||||
}
|
||||
|
||||
// Batch (TSeries)
|
||||
var batch = Normdist.Batch(source, period: period);
|
||||
|
||||
// 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];
|
||||
Normdist.Batch(rawValues, spanOutput, period: period);
|
||||
|
||||
// Eventing
|
||||
var eventResults = new List<double>();
|
||||
var eventSource = new TSeries();
|
||||
var eventIndicator = new Normdist(eventSource, period: period);
|
||||
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 across 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;
|
||||
int period = 15;
|
||||
var gbm = new GBM(startPrice: 50, mu: 0.0, sigma: 0.3, seed: 72003);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
var streaming = new Normdist(period: period);
|
||||
var streamingVals = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
streaming.Update(source[i]);
|
||||
streamingVals[i] = streaming.Last.Value;
|
||||
}
|
||||
|
||||
var batch = Normdist.Batch(source, period: period);
|
||||
|
||||
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>(() =>
|
||||
Normdist.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>(() =>
|
||||
Normdist.Batch(src, dst));
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_InvalidSigma_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Normdist.Batch(src, dst, sigma: 0.0));
|
||||
Assert.Equal("sigma", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_NegativeSigma_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Normdist.Batch(src, dst, sigma: -1.0));
|
||||
Assert.Equal("sigma", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_InvalidPeriod_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Normdist.Batch(src, dst, period: 1));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_OutputInRange()
|
||||
{
|
||||
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));
|
||||
|
||||
double[] src = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
src[i] = bars.Close[i].Value;
|
||||
}
|
||||
|
||||
double[] dst = new double[count];
|
||||
Normdist.Batch(src, dst, period: 20);
|
||||
|
||||
foreach (double v in dst)
|
||||
{
|
||||
Assert.True(v >= 0.0 && v <= 1.0, $"Output {v} out of [0,1] range");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_HandlesNaN()
|
||||
{
|
||||
double[] src = { 100.0, double.NaN, 102.0, 98.0, 105.0, 103.0 };
|
||||
double[] dst = new double[src.Length];
|
||||
Normdist.Batch(src, dst, period: 4);
|
||||
|
||||
foreach (double v in dst)
|
||||
{
|
||||
Assert.True(double.IsFinite(v), "Span output should always be finite");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_NoStackOverflow_LargeData()
|
||||
{
|
||||
int count = 5000;
|
||||
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];
|
||||
Normdist.Batch(src, dst, period: 300);
|
||||
|
||||
foreach (double v in dst)
|
||||
{
|
||||
Assert.True(double.IsFinite(v));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_MatchesStreaming()
|
||||
{
|
||||
int count = 60;
|
||||
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[] src = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
src[i] = bars.Close[i].Value;
|
||||
}
|
||||
|
||||
double[] spanOut = new double[count];
|
||||
Normdist.Batch(src, spanOut, period: 14);
|
||||
|
||||
var streaming = new Normdist(period: 14);
|
||||
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 Normdist(period: 3);
|
||||
int count = 0;
|
||||
indicator.Pub += (object? sender, in TValueEventArgs args) => count++;
|
||||
|
||||
var time = DateTime.UtcNow;
|
||||
indicator.Update(new TValue(time, 100.0));
|
||||
indicator.Update(new TValue(time.AddMinutes(1), 102.0));
|
||||
indicator.Update(new TValue(time.AddMinutes(2), 98.0));
|
||||
|
||||
Assert.Equal(3, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Chaining_Constructor_Works()
|
||||
{
|
||||
int period = 5;
|
||||
var source = new TSeries();
|
||||
var indicator = new Normdist(source, period: period);
|
||||
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
source.Add(new TValue(time, p), true);
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
Assert.True(indicator.Last.Value >= 0.0 && indicator.Last.Value <= 1.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Pub_EventValue_MatchesLast()
|
||||
{
|
||||
var indicator = new Normdist(period: 5);
|
||||
TValue? lastEvent = null;
|
||||
indicator.Pub += (object? s, in TValueEventArgs e) => lastEvent = e.Value;
|
||||
|
||||
var time = DateTime.UtcNow;
|
||||
double[] prices = { 100.0, 102.0, 98.0, 105.0, 103.0 };
|
||||
|
||||
foreach (var p in prices)
|
||||
{
|
||||
indicator.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
}
|
||||
|
||||
Assert.NotNull(lastEvent);
|
||||
Assert.Equal(indicator.Last.Value, lastEvent.Value.Value, Tolerance);
|
||||
}
|
||||
|
||||
// ─── Additional: Parameter effects ───────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void DifferentSigma_ProduceDifferentResults()
|
||||
{
|
||||
int count = 60;
|
||||
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 ind1 = new Normdist(mu: 0.0, sigma: 0.5, period: 20);
|
||||
var ind2 = new Normdist(mu: 0.0, sigma: 1.0, period: 20);
|
||||
var ind3 = new Normdist(mu: 0.0, sigma: 3.0, period: 20);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
ind1.Update(bars.Close[i]);
|
||||
ind2.Update(bars.Close[i]);
|
||||
ind3.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
// Larger sigma compresses S-curve (output closer to 0.5)
|
||||
// All outputs still in [0,1]
|
||||
Assert.InRange(ind1.Last.Value, 0.0, 1.0);
|
||||
Assert.InRange(ind2.Last.Value, 0.0, 1.0);
|
||||
Assert.InRange(ind3.Last.Value, 0.0, 1.0);
|
||||
// Different sigma → different results
|
||||
Assert.NotEqual(ind1.Last.Value, ind3.Last.Value, 1e-4);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_StaticMethod_ReturnsTuple()
|
||||
{
|
||||
int count = 50;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72007);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var (results, instance) = Normdist.Calculate(bars.Close, period: 20);
|
||||
|
||||
Assert.Equal(count, results.Count);
|
||||
Assert.True(instance.IsHot);
|
||||
Assert.Equal(results[^1].Value, instance.Last.Value, Tolerance);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,421 @@
|
||||
using Xunit;
|
||||
using MathNet.Numerics.Distributions;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// NormdistValidationTests — validates against known mathematical properties
|
||||
/// of the Normal Distribution CDF and against MathNet.Numerics Normal.
|
||||
/// Known-value tests call Normdist.StaticCdf / NormalCdf directly (bypassing windowing)
|
||||
/// so results are exact closed-form comparisons.
|
||||
/// Tolerance 1e-4 for the 3-term A&S approximation (max error ~2.5e-5);
|
||||
/// Using 1e-4 to give headroom. MathNet cross-validation uses 1e-4.
|
||||
/// </summary>
|
||||
public class NormdistValidationTests
|
||||
{
|
||||
private const double ApproxTolerance = 1e-4; // A&S 3-term max error ~2.5e-5
|
||||
private const double LooseTolerance = 1e-3;
|
||||
|
||||
// ─── Boundary: CDF at extreme negative → 0 ───────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 1.0)]
|
||||
[InlineData(0.5, 1.0)]
|
||||
[InlineData(0.0, 2.0)]
|
||||
public void StaticCdf_AtVeryNegativeX_ApproachesZero(double mu, double sigma)
|
||||
{
|
||||
double cdf = Normdist.StaticCdf(-100.0, mu, sigma);
|
||||
Assert.True(cdf < 1e-6, $"CDF at x=-100 should approach 0, got {cdf}");
|
||||
}
|
||||
|
||||
// ─── Boundary: CDF at extreme positive → 1 ───────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 1.0)]
|
||||
[InlineData(0.5, 1.0)]
|
||||
[InlineData(0.0, 2.0)]
|
||||
public void StaticCdf_AtVeryPositiveX_ApproachesOne(double mu, double sigma)
|
||||
{
|
||||
double cdf = Normdist.StaticCdf(100.0, mu, sigma);
|
||||
Assert.True(cdf > 1.0 - 1e-6, $"CDF at x=100 should approach 1, got {cdf}");
|
||||
}
|
||||
|
||||
// ─── Symmetry: CDF(mu) = 0.5 ─────────────────────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 1.0)]
|
||||
[InlineData(1.0, 1.0)]
|
||||
[InlineData(-2.5, 1.0)]
|
||||
[InlineData(0.0, 0.5)]
|
||||
[InlineData(3.0, 2.0)]
|
||||
public void StaticCdf_AtMean_IsHalf(double mu, double sigma)
|
||||
{
|
||||
double cdf = Normdist.StaticCdf(mu, mu, sigma);
|
||||
Assert.Equal(0.5, cdf, ApproxTolerance);
|
||||
}
|
||||
|
||||
// ─── Known percentiles for standard normal (μ=0, σ=1) ───────────────────
|
||||
|
||||
[Fact]
|
||||
public void StaticCdf_StandardNormal_AtPlusSigma_Is0841()
|
||||
{
|
||||
// Φ(1) ≈ 0.8413447...
|
||||
double cdf = Normdist.StaticCdf(1.0, 0.0, 1.0);
|
||||
Assert.Equal(0.8413, cdf, 3);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StaticCdf_StandardNormal_AtMinusSigma_Is0159()
|
||||
{
|
||||
// Φ(-1) ≈ 0.1586553...
|
||||
double cdf = Normdist.StaticCdf(-1.0, 0.0, 1.0);
|
||||
Assert.Equal(0.1587, cdf, 3);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StaticCdf_StandardNormal_AtPlus2Sigma_Is0977()
|
||||
{
|
||||
// Φ(2) ≈ 0.9772499...
|
||||
double cdf = Normdist.StaticCdf(2.0, 0.0, 1.0);
|
||||
Assert.Equal(0.9772, cdf, 3);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StaticCdf_StandardNormal_AtMinus2Sigma_Is0023()
|
||||
{
|
||||
// Φ(-2) ≈ 0.0227501...
|
||||
double cdf = Normdist.StaticCdf(-2.0, 0.0, 1.0);
|
||||
Assert.Equal(0.0228, cdf, 3);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StaticCdf_StandardNormal_At196_Is0975()
|
||||
{
|
||||
// Φ(1.96) ≈ 0.975 (95th percentile)
|
||||
double cdf = Normdist.StaticCdf(1.96, 0.0, 1.0);
|
||||
Assert.Equal(0.975, cdf, ApproxTolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StaticCdf_StandardNormal_At2326_Is0990()
|
||||
{
|
||||
// Φ(2.326) ≈ 0.990 (99th percentile)
|
||||
double cdf = Normdist.StaticCdf(2.326, 0.0, 1.0);
|
||||
Assert.Equal(0.990, cdf, 2);
|
||||
}
|
||||
|
||||
// ─── Complementary: Φ(x) + Φ(-x) = 1 ────────────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.5)]
|
||||
[InlineData(1.0)]
|
||||
[InlineData(1.5)]
|
||||
[InlineData(2.0)]
|
||||
[InlineData(0.1)]
|
||||
public void StaticCdf_Symmetry_ComplementTo1(double z)
|
||||
{
|
||||
double pos = Normdist.StaticCdf(z, 0.0, 1.0);
|
||||
double neg = Normdist.StaticCdf(-z, 0.0, 1.0);
|
||||
Assert.Equal(1.0, pos + neg, ApproxTolerance);
|
||||
}
|
||||
|
||||
// ─── MathNet.Numerics cross-validation ───────────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 0.0, 1.0)]
|
||||
[InlineData(1.0, 0.0, 1.0)]
|
||||
[InlineData(-1.0, 0.0, 1.0)]
|
||||
[InlineData(2.0, 0.0, 1.0)]
|
||||
[InlineData(-2.0, 0.0, 1.0)]
|
||||
[InlineData(1.0, 1.0, 1.0)]
|
||||
[InlineData(0.5, 0.0, 2.0)]
|
||||
[InlineData(3.0, 2.0, 0.5)]
|
||||
[InlineData(-1.0, 0.0, 0.5)]
|
||||
[InlineData(1.96, 0.0, 1.0)]
|
||||
public void StaticCdf_VsMathNet_KnownValues(double x, double mu, double sigma)
|
||||
{
|
||||
var dist = new Normal(mu, sigma);
|
||||
double expected = dist.CumulativeDistribution(x);
|
||||
double actual = Normdist.StaticCdf(x, mu, sigma);
|
||||
Assert.Equal(expected, actual, ApproxTolerance);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 0.0, 1.0)]
|
||||
[InlineData(1.0, 0.0, 1.0)]
|
||||
[InlineData(-1.0, 0.0, 1.0)]
|
||||
[InlineData(0.5, 0.5, 1.5)]
|
||||
[InlineData(2.5, 1.0, 2.0)]
|
||||
public void NormalCdf_VsMathNet_KnownValues(double x, double mu, double sigma)
|
||||
{
|
||||
var dist = new Normal(mu, sigma);
|
||||
double expected = dist.CumulativeDistribution(x);
|
||||
double actual = Normdist.NormalCdf(x, mu, sigma);
|
||||
Assert.Equal(expected, actual, ApproxTolerance);
|
||||
}
|
||||
|
||||
// ─── Monotonicity ─────────────────────────────────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 1.0)]
|
||||
[InlineData(1.0, 0.5)]
|
||||
[InlineData(-1.0, 2.0)]
|
||||
public void StaticCdf_MonotonicIncreasing(double mu, double sigma)
|
||||
{
|
||||
double prev = -1.0;
|
||||
|
||||
for (int i = -30; i <= 30; i++)
|
||||
{
|
||||
double x = i * 0.3;
|
||||
double cdf = Normdist.StaticCdf(x, mu, sigma);
|
||||
Assert.True(cdf >= prev - LooseTolerance,
|
||||
$"CDF not monotonic at x={x} (μ={mu}, σ={sigma}): got {cdf}, prev={prev}");
|
||||
prev = cdf;
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Output bounded [0, 1] with streaming indicator ──────────────────────
|
||||
|
||||
[Fact]
|
||||
public void NormdistCdf_OutputBounded_Zero_To_One()
|
||||
{
|
||||
int count = 200;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 75001);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Normdist(mu: 0.0, sigma: 1.0, period: 20);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
double v = indicator.Last.Value;
|
||||
Assert.True(v >= 0.0 && v <= 1.0, $"Output {v} at bar {i} out of [0,1]");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Flat range → CDF = 0.5 (z=0, erf(0)=0) ─────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void NormdistCdf_FlatRange_ReturnsHalf()
|
||||
{
|
||||
// When all values in window are identical: stddev=0, z=0 → Φ(0)=0.5
|
||||
var ind = new Normdist(mu: 0.0, sigma: 1.0, period: 10);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
ind.Update(new TValue(time.AddSeconds(i), 100.0));
|
||||
}
|
||||
|
||||
Assert.Equal(0.5, ind.Last.Value, LooseTolerance);
|
||||
}
|
||||
|
||||
// ─── z-score interpretation: above mean → > 0.5, below mean → < 0.5 ─────
|
||||
|
||||
[Fact]
|
||||
public void NormdistCdf_AboveMean_GreaterThanHalf()
|
||||
{
|
||||
// Feed data with clear trend up; last bar well above rolling mean → CDF > 0.5
|
||||
var ind = new Normdist(mu: 0.0, sigma: 1.0, period: 10);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Flat base, then spike
|
||||
for (int i = 0; i < 9; i++)
|
||||
{
|
||||
ind.Update(new TValue(time.AddMinutes(i), 100.0));
|
||||
}
|
||||
ind.Update(new TValue(time.AddMinutes(9), 110.0)); // spike: well above mean/stddev
|
||||
|
||||
Assert.True(ind.Last.Value > 0.5, $"Above-mean value should give CDF > 0.5, got {ind.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NormdistCdf_BelowMean_LessThanHalf()
|
||||
{
|
||||
// Feed flat data, then dip → CDF < 0.5
|
||||
var ind = new Normdist(mu: 0.0, sigma: 1.0, period: 10);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 9; i++)
|
||||
{
|
||||
ind.Update(new TValue(time.AddMinutes(i), 100.0));
|
||||
}
|
||||
ind.Update(new TValue(time.AddMinutes(9), 90.0)); // dip: well below mean
|
||||
|
||||
Assert.True(ind.Last.Value < 0.5, $"Below-mean value should give CDF < 0.5, got {ind.Last.Value}");
|
||||
}
|
||||
|
||||
// ─── Erf internal correctness ─────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Erf_AtZero_IsZero()
|
||||
{
|
||||
Assert.Equal(0.0, Normdist.Erf(0.0), 1e-10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Erf_AtLargePositive_ApproachesOne()
|
||||
{
|
||||
double v = Normdist.Erf(5.0);
|
||||
Assert.True(v > 0.999, $"erf(5) should approach 1, got {v}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Erf_IsOddFunction()
|
||||
{
|
||||
// erf(-x) = -erf(x)
|
||||
double[] testX = { 0.5, 1.0, 1.5, 2.0, 3.0 };
|
||||
foreach (double x in testX)
|
||||
{
|
||||
double pos = Normdist.Erf(x);
|
||||
double neg = Normdist.Erf(-x);
|
||||
Assert.Equal(-pos, neg, ApproxTolerance);
|
||||
}
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 0.0)] // erf(0) = 0
|
||||
[InlineData(0.5, 0.5204998778)] // known value
|
||||
[InlineData(1.0, 0.8427007929)] // known value
|
||||
[InlineData(2.0, 0.9953222650)] // known value
|
||||
public void Erf_KnownValues_WithinApproxTolerance(double x, double expected)
|
||||
{
|
||||
double actual = Normdist.Erf(x);
|
||||
Assert.Equal(expected, actual, ApproxTolerance);
|
||||
}
|
||||
|
||||
// ─── Span batch consistency ───────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_MatchesTSeries()
|
||||
{
|
||||
int count = 150;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.25, seed: 75002);
|
||||
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 = Normdist.Batch(bars.Close, period: 30);
|
||||
double[] spanResult = new double[count];
|
||||
Normdist.Batch(rawValues, spanResult, period: 30);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Assert.Equal(tseriesResult[i].Value, spanResult[i], 1e-10);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Streaming convergence ────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void NormdistCdf_HighPeriod_StillConverges()
|
||||
{
|
||||
int period = 200;
|
||||
var indicator = new Normdist(mu: 0.0, sigma: 1.0, period: period);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 75003);
|
||||
var bars = gbm.Fetch(period + 50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
for (int i = 0; i < bars.Close.Count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
Assert.True(double.IsFinite(indicator.Last.Value),
|
||||
$"Non-finite output at bar {i}");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Parameter combos all within [0,1] ────────────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.0, 0.5, 5)]
|
||||
[InlineData(0.0, 1.0, 14)]
|
||||
[InlineData(0.5, 1.0, 10)]
|
||||
[InlineData(0.0, 2.0, 20)]
|
||||
[InlineData(-1.0, 1.0, 30)]
|
||||
public void NormdistCdf_ParameterCombos_OutputBounded(double mu, double sigma, int period)
|
||||
{
|
||||
int count = period + 50;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 75004 + (int)(sigma * 100));
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Normdist(mu, sigma, period);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
indicator.Update(bars.Close[i]);
|
||||
double v = indicator.Last.Value;
|
||||
Assert.True(v >= 0.0 && v <= 1.0,
|
||||
$"Out of [0,1] at bar {i}: {v} (μ={mu}, σ={sigma}, period={period})");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Large dataset stable ─────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void NormdistCdf_LargeDataset_Stable()
|
||||
{
|
||||
int count = 2000;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 75005);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Normdist(mu: 0.0, sigma: 1.0, period: 50);
|
||||
|
||||
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 && v <= 1.0,
|
||||
$"Invalid output {v} at bar {i}");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Multiple points all match MathNet ───────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void StaticCdf_MultiplePoints_AllMatchMathNet()
|
||||
{
|
||||
double mu = 0.0, sigma = 1.0;
|
||||
var dist = new Normal(mu, sigma);
|
||||
|
||||
double[] testX = { -3.0, -2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 3.0 };
|
||||
|
||||
foreach (double x in testX)
|
||||
{
|
||||
double expected = dist.CumulativeDistribution(x);
|
||||
double actual = Normdist.StaticCdf(x, mu, sigma);
|
||||
Assert.Equal(expected, actual, ApproxTolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── NormalCdf invalid sigma returns 0.5 ──────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void NormalCdf_ZeroSigma_ReturnsHalf()
|
||||
{
|
||||
double cdf = Normdist.NormalCdf(1.0, 0.0, 0.0);
|
||||
Assert.Equal(0.5, cdf, 1e-10);
|
||||
}
|
||||
|
||||
// ─── Sigma effect: larger sigma compresses S-curve toward 0.5 ─────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(1.0, 0.0)]
|
||||
[InlineData(2.0, 0.0)]
|
||||
[InlineData(0.5, 0.0)]
|
||||
public void StaticCdf_LargerSigma_CompressesCurve(double x, double mu)
|
||||
{
|
||||
// For x > mu, larger sigma → smaller (z-mu)/sigma → CDF closer to 0.5
|
||||
double cdf1 = Normdist.StaticCdf(x, mu, 0.5);
|
||||
double cdf2 = Normdist.StaticCdf(x, mu, 1.0);
|
||||
double cdf3 = Normdist.StaticCdf(x, mu, 3.0);
|
||||
|
||||
// Larger sigma → CDF closer to 0.5 (smaller z)
|
||||
Assert.True(cdf1 >= cdf2 - LooseTolerance,
|
||||
$"σ=0.5 CDF={cdf1} should be >= σ=1.0 CDF={cdf2} for x>mu");
|
||||
Assert.True(cdf2 >= cdf3 - LooseTolerance,
|
||||
$"σ=1.0 CDF={cdf2} should be >= σ=3.0 CDF={cdf3} for x>mu");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user