mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-23 13:08: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,656 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class BinomdistTests
|
||||
{
|
||||
private const double Tolerance = 1e-10;
|
||||
|
||||
// ─── A) Constructor validation ────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Constructor_DefaultParameters_SetsProperties()
|
||||
{
|
||||
var indicator = new Binomdist();
|
||||
Assert.Equal("Binomdist(50,20,10)", indicator.Name);
|
||||
Assert.Equal(50, indicator.WarmupPeriod);
|
||||
Assert.False(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_CustomParameters_SetsName()
|
||||
{
|
||||
var indicator = new Binomdist(30, 15, 7);
|
||||
Assert.Equal("Binomdist(30,15,7)", indicator.Name);
|
||||
Assert.Equal(30, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_InvalidPeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Binomdist(period: 0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativePeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Binomdist(period: -1));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroTrials_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Binomdist(trials: 0));
|
||||
Assert.Equal("trials", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativeTrials_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Binomdist(trials: -5));
|
||||
Assert.Equal("trials", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativeThreshold_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Binomdist(threshold: -1));
|
||||
Assert.Equal("threshold", ex.ParamName);
|
||||
}
|
||||
|
||||
// ─── B) Basic calculation ─────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsValidTValue()
|
||||
{
|
||||
var indicator = new Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 3, trials: 10, threshold: 5);
|
||||
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 Binomdist(period: 5, trials: 10, threshold: 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);
|
||||
}
|
||||
|
||||
// ─── C) State + bar correction ────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNewTrue_AdvancesState()
|
||||
{
|
||||
var indicator = new Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 5, trials: 10, threshold: 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 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: 43001);
|
||||
var bars = gbm.Fetch(20, time.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
// Streaming without corrections
|
||||
var straight = new Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period, trials: 10, threshold: 5);
|
||||
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");
|
||||
}
|
||||
|
||||
// ─── E) Robustness ────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Update_NaN_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 5, trials: 10, threshold: 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 Binomdist(period: 5, trials: 10, threshold: 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_FlatRange_ReturnsExpectedCdf()
|
||||
{
|
||||
// When all values in window are identical, range=0 → p=0.5
|
||||
// P(X≤5; n=10, p=0.5) = 0.623046875 (exact)
|
||||
var indicator = new Binomdist(period: 5, trials: 10, threshold: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(new TValue(time.AddMinutes(i), 100.0));
|
||||
}
|
||||
|
||||
// p=0.5, n=10, k=5: exact = 0.623046875
|
||||
Assert.True(Math.Abs(indicator.Last.Value - 0.623046875) < 1e-9,
|
||||
$"Expected ~0.623046875 but got {indicator.Last.Value}");
|
||||
}
|
||||
|
||||
// ─── 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: 43002);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
// Streaming
|
||||
var streaming = new Binomdist(period, trials: 15, threshold: 7);
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
streaming.Update(source[i]);
|
||||
}
|
||||
|
||||
// Batch (TSeries)
|
||||
var batch = Binomdist.Batch(source, period, trials: 15, threshold: 7);
|
||||
|
||||
// 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];
|
||||
Binomdist.Batch(rawValues, spanOutput, period, trials: 15, threshold: 7);
|
||||
|
||||
// Eventing
|
||||
var eventResults = new List<double>();
|
||||
var eventSource = new TSeries();
|
||||
var eventIndicator = new Binomdist(eventSource, period, trials: 15, threshold: 7);
|
||||
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: 43003);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
var streaming = new Binomdist(period, trials: 10, threshold: 5);
|
||||
var streamingVals = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
streaming.Update(source[i]);
|
||||
streamingVals[i] = streaming.Last.Value;
|
||||
}
|
||||
|
||||
var batch = Binomdist.Batch(source, period, trials: 10, threshold: 5);
|
||||
|
||||
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>(() =>
|
||||
Binomdist.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>(() =>
|
||||
Binomdist.Batch(src, dst));
|
||||
Assert.Equal("output", 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>(() =>
|
||||
Binomdist.Batch(src, dst, period: 0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_InvalidTrials_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Binomdist.Batch(src, dst, trials: 0));
|
||||
Assert.Equal("trials", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_InvalidThreshold_ThrowsArgumentException()
|
||||
{
|
||||
double[] src = { 1.0, 2.0, 3.0 };
|
||||
double[] dst = new double[3];
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Binomdist.Batch(src, dst, threshold: -1));
|
||||
Assert.Equal("threshold", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_OutputInRange()
|
||||
{
|
||||
int count = 100;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 43004);
|
||||
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];
|
||||
Binomdist.Batch(src, dst, period: 20, trials: 10, threshold: 5);
|
||||
|
||||
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];
|
||||
Binomdist.Batch(src, dst, period: 5);
|
||||
|
||||
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];
|
||||
Binomdist.Batch(src, dst, period: 300, trials: 20, threshold: 10);
|
||||
|
||||
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: 43005);
|
||||
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];
|
||||
Binomdist.Batch(src, spanOut, period: 14, trials: 10, threshold: 5);
|
||||
|
||||
var streaming = new Binomdist(period: 14, trials: 10, threshold: 5);
|
||||
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 Binomdist(period: 3, trials: 10, threshold: 5);
|
||||
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 Binomdist(source, period, trials: 10, threshold: 5);
|
||||
|
||||
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 Binomdist(period: 5, trials: 10, threshold: 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 combinations ───────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void DifferentTrialsThreshold_ProduceDifferentResults()
|
||||
{
|
||||
int count = 60;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 43006);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var ind1 = new Binomdist(period: 20, trials: 10, threshold: 3);
|
||||
var ind2 = new Binomdist(period: 20, trials: 10, threshold: 5);
|
||||
var ind3 = new Binomdist(period: 20, trials: 20, threshold: 5);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
ind1.Update(bars.Close[i]);
|
||||
ind2.Update(bars.Close[i]);
|
||||
ind3.Update(bars.Close[i]);
|
||||
}
|
||||
|
||||
Assert.NotEqual(ind1.Last.Value, ind2.Last.Value, 1e-4);
|
||||
Assert.NotEqual(ind2.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: 43007);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var (results, instance) = Binomdist.Calculate(bars.Close, period: 20);
|
||||
|
||||
Assert.Equal(count, results.Count);
|
||||
Assert.True(instance.IsHot);
|
||||
Assert.Equal(results[^1].Value, instance.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ThresholdZero_ProbabilityIsNearZeroForMidP()
|
||||
{
|
||||
// P(X<=0; n=10, p=0.5) = 0.5^10 ≈ 0.000977
|
||||
double cdf = Binomdist.BinomialCdf(0.5, 10, 0);
|
||||
Assert.True(Math.Abs(cdf - 0.0009765625) < 1e-10, $"Expected 0.0009765625 got {cdf}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ThresholdEqualN_ProbabilityIsOne()
|
||||
{
|
||||
// P(X<=n; n, p) = 1 for any p in (0,1)
|
||||
double cdf = Binomdist.BinomialCdf(0.7, 10, 10);
|
||||
Assert.Equal(1.0, cdf, 1e-10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProbabilityZero_AlwaysReturnsOne()
|
||||
{
|
||||
// p=0: all mass at X=0, so P(X<=k) = 1 for k >= 0
|
||||
double cdf = Binomdist.BinomialCdf(0.0, 10, 5);
|
||||
Assert.Equal(1.0, cdf, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProbabilityOne_ReturnsOneOnlyIfKGreaterEqualN()
|
||||
{
|
||||
// p=1: all mass at X=n, so P(X<=k) = 1 iff k >= n
|
||||
double cdfAtN = Binomdist.BinomialCdf(1.0, 10, 10);
|
||||
double cdfBelowN = Binomdist.BinomialCdf(1.0, 10, 5);
|
||||
Assert.Equal(1.0, cdfAtN, Tolerance);
|
||||
Assert.Equal(0.0, cdfBelowN, Tolerance);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Binomdist validation tests — validates PMF/CDF against exact combinatorial values.
|
||||
/// Known-value tests call Binomdist.BinomialCdf directly (bypassing windowing) so
|
||||
/// results are exact. Streaming/batch tests check invariants that hold regardless
|
||||
/// of window state.
|
||||
/// </summary>
|
||||
public class BinomdistValidationTests
|
||||
{
|
||||
private const double Tolerance = 1e-9;
|
||||
private const double LooseTolerance = 1e-6;
|
||||
|
||||
// ─── PMF known values ────────────────────────────────────────────────────
|
||||
// P(X=k; n, p) = C(n,k) * p^k * (1-p)^(n-k)
|
||||
// CDF P(X<=k) = sum_{i=0}^{k} P(X=i)
|
||||
|
||||
[Theory]
|
||||
// P(X=3; n=10, p=0.5) = C(10,3) * 0.5^10 = 120/1024 = 0.1171875
|
||||
// CDF P(X<=3; n=10, p=0.5) = (1+10+45+120)/1024 = 176/1024 = 0.171875
|
||||
[InlineData(0.5, 10, 3, 0.171875)]
|
||||
// P(X<=5; n=10, p=0.5) = 638/1024 = 0.623046875 (exact)
|
||||
[InlineData(0.5, 10, 5, 0.623046875)]
|
||||
// P(X<=0; n=5, p=0.3) = (0.7)^5 = 0.16807
|
||||
[InlineData(0.3, 5, 0, 0.16807)]
|
||||
// P(X<=5; n=5, p=0.3) = 1.0 (k >= n)
|
||||
[InlineData(0.3, 5, 5, 1.0)]
|
||||
// P(X<=0; n=10, p=0.5) = 0.5^10 = 1/1024 ≈ 0.0009765625
|
||||
[InlineData(0.5, 10, 0, 0.0009765625)]
|
||||
// P(X<=10; n=10, p=0.5) = 1.0
|
||||
[InlineData(0.5, 10, 10, 1.0)]
|
||||
// P(X<=0; n=1, p=0.5) = 0.5
|
||||
[InlineData(0.5, 1, 0, 0.5)]
|
||||
// P(X<=1; n=1, p=0.5) = 1.0
|
||||
[InlineData(0.5, 1, 1, 1.0)]
|
||||
// P(X<=2; n=5, p=0.5) = (1+5+10)/32 = 16/32 = 0.5
|
||||
[InlineData(0.5, 5, 2, 0.5)]
|
||||
// P(X<=4; n=5, p=0.3) = 1 - P(X=5) = 1 - 0.3^5 = 1 - 0.00243 = 0.99757
|
||||
[InlineData(0.3, 5, 4, 0.99757)]
|
||||
public void BinomCdf_KnownValues(double p, int n, int k, double expected)
|
||||
{
|
||||
double actual = Binomdist.BinomialCdf(p, n, k);
|
||||
Assert.Equal(expected, actual, LooseTolerance);
|
||||
}
|
||||
|
||||
// ─── PMF direct known values ─────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BinomPmf_Exact_n10_p05_k3()
|
||||
{
|
||||
// P(X=3; n=10, p=0.5) = C(10,3) / 2^10 = 120/1024 = 0.1171875
|
||||
// PMF = CDF(k) - CDF(k-1)
|
||||
double cdfK = Binomdist.BinomialCdf(0.5, 10, 3);
|
||||
double cdfKm1 = Binomdist.BinomialCdf(0.5, 10, 2);
|
||||
double pmf = cdfK - cdfKm1;
|
||||
Assert.Equal(0.1171875, pmf, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BinomPmf_Exact_n5_p03_k0()
|
||||
{
|
||||
// P(X=0; n=5, p=0.3) = (0.7)^5 = 0.16807
|
||||
// CDF(0) - CDF(-1) = CDF(0) = 0.16807
|
||||
double cdf = Binomdist.BinomialCdf(0.3, 5, 0);
|
||||
Assert.Equal(0.16807, cdf, Tolerance);
|
||||
}
|
||||
|
||||
// ─── Monotonicity ─────────────────────────────────────────────────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(0.3, 10)]
|
||||
[InlineData(0.5, 10)]
|
||||
[InlineData(0.7, 20)]
|
||||
[InlineData(0.1, 5)]
|
||||
public void BinomCdf_Monotonic_InK(double p, int n)
|
||||
{
|
||||
// CDF must be non-decreasing in k
|
||||
double prev = 0.0;
|
||||
for (int k = 0; k <= n; k++)
|
||||
{
|
||||
double cdf = Binomdist.BinomialCdf(p, n, k);
|
||||
Assert.True(cdf >= prev - 1e-12,
|
||||
$"CDF not monotonic at k={k}, p={p}, n={n}: got {cdf}, prev={prev}");
|
||||
prev = cdf;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_MonotonicInP()
|
||||
{
|
||||
// P(X<=5; n=10, p) must be bounded [0,1] for all p
|
||||
int n = 10, k = 5;
|
||||
for (int i = 1; i <= 9; i++)
|
||||
{
|
||||
double p = i / 10.0;
|
||||
double cdf = Binomdist.BinomialCdf(p, n, k);
|
||||
Assert.True(cdf >= 0.0 && cdf <= 1.0,
|
||||
$"CDF out of bounds: {cdf} at p={p}");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Boundary behavior ────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_P_Zero_ReturnsOne()
|
||||
{
|
||||
Assert.Equal(1.0, Binomdist.BinomialCdf(0.0, 10, 0), Tolerance);
|
||||
Assert.Equal(1.0, Binomdist.BinomialCdf(0.0, 10, 10), Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_P_One_KLessN_ReturnsZero()
|
||||
{
|
||||
Assert.Equal(0.0, Binomdist.BinomialCdf(1.0, 10, 5), Tolerance);
|
||||
Assert.Equal(0.0, Binomdist.BinomialCdf(1.0, 10, 9), Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_P_One_KEqualN_ReturnsOne()
|
||||
{
|
||||
Assert.Equal(1.0, Binomdist.BinomialCdf(1.0, 10, 10), Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_KN_ReturnsOne()
|
||||
{
|
||||
// P(X<=n; n, p) = 1 for all p in (0,1)
|
||||
Assert.Equal(1.0, Binomdist.BinomialCdf(0.3, 5, 5), Tolerance);
|
||||
Assert.Equal(1.0, Binomdist.BinomialCdf(0.5, 10, 10), Tolerance);
|
||||
Assert.Equal(1.0, Binomdist.BinomialCdf(0.9, 20, 20), Tolerance);
|
||||
}
|
||||
|
||||
// ─── Output bounds ─────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_OutputBounded_Zero_To_One()
|
||||
{
|
||||
int count = 200;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 52001);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Binomdist(period: 20, trials: 10, threshold: 5);
|
||||
|
||||
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 → neutral CDF ─────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_FlatRange_ReturnsSymmetricCdf()
|
||||
{
|
||||
// Flat range → p=0.5; for symmetric n=10, k=5: CDF = 0.623046875
|
||||
var ind = new Binomdist(20, trials: 10, threshold: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
ind.Update(new TValue(time.AddSeconds(i), 100.0));
|
||||
}
|
||||
|
||||
Assert.Equal(0.623046875, ind.Last.Value, LooseTolerance);
|
||||
}
|
||||
|
||||
// ─── Period=1 trivial case ────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_Period1_AlwaysReturnsCdfAtHalf()
|
||||
{
|
||||
// period=1: single-element window → range=0 → p=0.5 always
|
||||
var ind = new Binomdist(1, trials: 10, threshold: 5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
double expected = Binomdist.BinomialCdf(0.5, 10, 5);
|
||||
double[] prices = { 100.0, 50.0, 200.0, 1.0, 1000.0 };
|
||||
foreach (double p in prices)
|
||||
{
|
||||
ind.Update(new TValue(time, p));
|
||||
time = time.AddMinutes(1);
|
||||
Assert.Equal(expected, ind.Last.Value, LooseTolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── 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: 52002);
|
||||
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 = Binomdist.Batch(bars.Close, period: 30, trials: 15, threshold: 7);
|
||||
double[] spanResult = new double[count];
|
||||
Binomdist.Batch(rawValues, spanResult, period: 30, trials: 15, threshold: 7);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Assert.Equal(tseriesResult[i].Value, spanResult[i], Tolerance);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Large n stability ────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_LargeN_Stable()
|
||||
{
|
||||
// Large n tests log-space summation's overflow avoidance
|
||||
double cdf = Binomdist.BinomialCdf(0.5, 100, 50);
|
||||
Assert.True(double.IsFinite(cdf) && cdf >= 0.0 && cdf <= 1.0,
|
||||
$"Large n CDF invalid: {cdf}");
|
||||
// n=100, k=50, p=0.5 should be near 0.54 (slightly above 0.5)
|
||||
Assert.True(cdf > 0.5 && cdf < 0.7, $"CDF={cdf} expected near 0.54");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_LargeDataset_Stable()
|
||||
{
|
||||
int count = 2000;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 52003);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Binomdist(period: 50, trials: 20, threshold: 10);
|
||||
|
||||
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}");
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Different parameter combos all produce output in range ──────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData(5, 5, 2)]
|
||||
[InlineData(14, 10, 5)]
|
||||
[InlineData(50, 20, 10)]
|
||||
[InlineData(100, 50, 25)]
|
||||
[InlineData(30, 1, 0)]
|
||||
public void BinomCdf_ParameterCombos_OutputBounded(int period, int trials, int threshold)
|
||||
{
|
||||
int count = period + 50;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 52004 + period);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var indicator = new Binomdist(period, trials, threshold);
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Streaming convergence ────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BinomCdf_HighPeriod_StillConverges()
|
||||
{
|
||||
int period = 200;
|
||||
var indicator = new Binomdist(period, trials: 20, threshold: 10);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 52005);
|
||||
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}");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user