gavindiaz/QuanTAlib
1
0
Fork 0
mirror of https://github.com/mihakralj/QuanTAlib.git synced 2026-08-22 04:28:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

adding missing validations

Browse Source
This commit is contained in:
Miha Kralj
2026-02-26 09:59:44 -08:00
parent 467a8c1cef
commit 9ab37c1200
231 changed files with 60015 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/numerics/gammadist/Gammadist.Quantower.Tests.cs
+201
View File
@@ -0,0 +1,201 @@
using Xunit;
using TradingPlatform.BusinessLayer;
namespace QuanTAlib.Tests;
public class GammadistIndicatorTests
{
[Fact]
public void GammadistIndicator_Constructor_SetsDefaults()
{
var indicator = new GammadistIndicator();
Assert.Equal(SourceType.Close, indicator.Source);
Assert.Equal(2.0, indicator.Alpha);
Assert.Equal(1.0, indicator.Beta);
Assert.Equal(14, indicator.Period);
Assert.True(indicator.ShowColdValues);
Assert.Equal("GAMMADIST - Gamma Distribution CDF", indicator.Name);
Assert.True(indicator.SeparateWindow);
Assert.True(indicator.OnBackGround);
}
[Fact]
public void GammadistIndicator_MinHistoryDepths_EqualsPeriod()
{
var indicator = new GammadistIndicator { Period = 30 };
Assert.Equal(30, indicator.MinHistoryDepths);
}
[Fact]
public void GammadistIndicator_ShortName_IsCorrect()
{
var indicator = new GammadistIndicator { Alpha = 3.0, Beta = 2.0, Period = 20 };
Assert.Equal("GAMMADIST(3.00,2.00,20)", indicator.ShortName);
}
[Fact]
public void GammadistIndicator_Initialize_CreatesTwoLineSeries()
{
var indicator = new GammadistIndicator();
indicator.Initialize();
Assert.Equal(2, indicator.LinesSeries.Count);
Assert.Equal("GammaDist", indicator.LinesSeries[0].Name);
Assert.Equal("Mid", indicator.LinesSeries[1].Name);
}
[Fact]
public void GammadistIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
{
var indicator = new GammadistIndicator { Alpha = 2.0, Beta = 1.0, Period = 5 };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 105 + i, 95 - i, 100 + i);
var args = new UpdateArgs(UpdateReason.HistoricalBar);
indicator.ProcessUpdate(args);
}
// After period bars, should have valid output
double val = indicator.LinesSeries[0].GetValue(0);
Assert.True(double.IsFinite(val), "Output must be finite after warmup");
Assert.True(val >= 0.0 && val <= 1.0, $"Output {val} must be in [0,1]");
}
[Fact]
public void GammadistIndicator_ProcessUpdate_NewBar_AddsNewValue()
{
var indicator = new GammadistIndicator { Alpha = 2.0, Beta = 1.0, Period = 3 };
indicator.Initialize();
var now = DateTime.UtcNow;
// Feed 3 historical bars
for (int i = 0; i < 3; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 105, 95, 100 + i);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
// Feed a new bar
indicator.HistoricalData.AddBar(now.AddMinutes(3), 0, 106, 96, 103);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
Assert.Equal(4, indicator.LinesSeries[0].Count);
}
[Fact]
public void GammadistIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
{
var indicator = new GammadistIndicator { Period = 3 };
indicator.Initialize();
var now = DateTime.UtcNow;
indicator.HistoricalData.AddBar(now, 0, 105, 95, 100);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
// 2 values: one historical, one intra-bar update
Assert.Equal(2, indicator.LinesSeries[0].Count);
}
[Fact]
public void GammadistIndicator_MidLine_IsAlwaysHalf()
{
var indicator = new GammadistIndicator { Period = 3 };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 105, 95, 100 + i);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
// Mid line should always be 0.5
for (int i = 0; i < indicator.LinesSeries[1].Count; i++)
{
double mid = indicator.LinesSeries[1].GetValue(i);
Assert.Equal(0.5, mid, 1e-10);
}
}
[Fact]
public void GammadistIndicator_DifferentSourceType_Works()
{
var indicator = new GammadistIndicator { Period = 3, Source = SourceType.High };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 3; i++)
{
// High = 110+i, Low = 90, Close = 100
indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 110 + i, 90, 100);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
double val = indicator.LinesSeries[0].GetValue(0);
Assert.True(double.IsFinite(val));
}
[Fact]
public void GammadistIndicator_OutputInRange_AfterManyBars()
{
var indicator = new GammadistIndicator { Alpha = 2.0, Beta = 1.0, Period = 20 };
indicator.Initialize();
var now = DateTime.UtcNow;
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 74001);
var bars = gbm.Fetch(50, now.Ticks, TimeSpan.FromMinutes(1));
for (int i = 0; i < bars.Close.Count; i++)
{
double price = bars.Close[i].Value;
indicator.HistoricalData.AddBar(
new DateTime(bars.Close[i].Time, DateTimeKind.Utc),
0, price * 1.01, price * 0.99, price);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
// Check all computed values are in [0, 1]
for (int i = 0; i < indicator.LinesSeries[0].Count; i++)
{
double val = indicator.LinesSeries[0].GetValue(i);
Assert.True(val >= 0.0 && val <= 1.0, $"Value {val} at index {i} out of range");
}
}
[Fact]
public void GammadistIndicator_HighAlpha_ValidOutput()
{
var indicator = new GammadistIndicator { Alpha = 10.0, Beta = 1.0, Period = 5 };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 101 + i, 99 + i, 100 + i);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
double val = indicator.LinesSeries[0].GetValue(0);
Assert.True(double.IsFinite(val));
Assert.True(val >= 0.0 && val <= 1.0);
}
[Fact]
public void GammadistIndicator_CustomParams_ShortNameReflects()
{
var indicator = new GammadistIndicator { Alpha = 3.0, Beta = 2.0, Period = 14 };
Assert.Equal("GAMMADIST(3.00,2.00,14)", indicator.ShortName);
}
[Fact]
public void GammadistIndicator_DefaultShortName_IsCorrect()
{
var indicator = new GammadistIndicator();
Assert.Equal("GAMMADIST(2.00,1.00,14)", indicator.ShortName);
}
}
lib/numerics/gammadist/Gammadist.Quantower.cs
+72
View File
@@ -0,0 +1,72 @@
using System.Drawing;
using TradingPlatform.BusinessLayer;
using static QuanTAlib.IndicatorExtensions;
namespace QuanTAlib;
/// <summary>
/// GAMMADIST (Gamma Distribution CDF) Quantower indicator.
/// Computes F(x; α, β) = P(α, x/β) applied to a min-max normalized price series
/// over a rolling lookback window.
/// </summary>
public class GammadistIndicator : Indicator, IWatchlistIndicator
{
[DataSourceInput]
public SourceType Source { get; set; } = SourceType.Close;
[InputParameter("Shape (α)", sortIndex: 0, minimum: 0.001, maximum: 100.0, increment: 0.1, decimalPlaces: 3)]
public double Alpha { get; set; } = 2.0;
[InputParameter("Scale (β)", sortIndex: 1, minimum: 0.001, maximum: 100.0, increment: 0.1, decimalPlaces: 3)]
public double Beta { get; set; } = 1.0;
[InputParameter("Period", sortIndex: 2, minimum: 2, maximum: 2000, increment: 1)]
public int Period { get; set; } = 14;
[InputParameter("Show Cold Values", sortIndex: 100)]
public bool ShowColdValues { get; set; } = true;
private Gammadist? _gammadist;
private Func<IHistoryItem, double>? _selector;
public int MinHistoryDepths => Period;
public override string ShortName => $"GAMMADIST({Alpha:F2},{Beta:F2},{Period})";
public GammadistIndicator()
{
Name = "GAMMADIST - Gamma Distribution CDF";
Description = "Applies the Gamma Distribution CDF to a min-max normalized price series";
SeparateWindow = true;
OnBackGround = true;
}
protected override void OnInit()
{
_gammadist = new Gammadist(Alpha, Beta, Period);
_selector = Source.GetPriceSelector();
AddLineSeries(new LineSeries("GammaDist", Color.Cyan, 2, LineStyle.Solid));
// Reference level at 0.5 (midpoint)
AddLineSeries(new LineSeries("Mid", Color.Gray, 1, LineStyle.Dash));
}
protected override void OnUpdate(UpdateArgs args)
{
if (_gammadist == null || _selector == null)
{
return;
}
var item = HistoricalData[0, SeekOriginHistory.End];
double value = _selector(item);
bool isNew = args.IsNewBar();
TValue input = new(item.TimeLeft, value);
_gammadist.Update(input, isNew);
bool isHot = _gammadist.IsHot;
LinesSeries[0].SetValue(_gammadist.Last.Value, isHot, ShowColdValues);
LinesSeries[1].SetValue(0.5, isHot, ShowColdValues);
}
}
lib/numerics/gammadist/Gammadist.Tests.cs
+685
View File
@@ -0,0 +1,685 @@
using Xunit;
namespace QuanTAlib.Tests;
public class GammadistTests
{
private const double Tolerance = 1e-10;
// ─── A) Constructor validation ────────────────────────────────────────────
[Fact]
public void Constructor_DefaultParameters_SetsProperties()
{
var indicator = new Gammadist();
Assert.Equal("Gammadist(2.00,1.00,14)", indicator.Name);
Assert.Equal(14, indicator.WarmupPeriod);
Assert.False(indicator.IsHot);
}
[Fact]
public void Constructor_CustomParameters_SetsName()
{
var indicator = new Gammadist(alpha: 3.0, beta: 2.0, period: 20);
Assert.Equal("Gammadist(3.00,2.00,20)", indicator.Name);
Assert.Equal(20, indicator.WarmupPeriod);
}
[Fact]
public void Constructor_ZeroAlpha_ThrowsArgumentException()
{
var ex = Assert.Throws<ArgumentException>(() => new Gammadist(alpha: 0.0));
Assert.Equal("alpha", ex.ParamName);
}
[Fact]
public void Constructor_NegativeAlpha_ThrowsArgumentException()
{
var ex = Assert.Throws<ArgumentException>(() => new Gammadist(alpha: -1.0));
Assert.Equal("alpha", ex.ParamName);
}
[Fact]
public void Constructor_ZeroBeta_ThrowsArgumentException()
{
var ex = Assert.Throws<ArgumentException>(() => new Gammadist(beta: 0.0));
Assert.Equal("beta", ex.ParamName);
}
[Fact]
public void Constructor_NegativeBeta_ThrowsArgumentException()
{
var ex = Assert.Throws<ArgumentException>(() => new Gammadist(beta: -0.5));
Assert.Equal("beta", ex.ParamName);
}
[Fact]
public void Constructor_PeriodOne_ThrowsArgumentException()
{
var ex = Assert.Throws<ArgumentException>(() => new Gammadist(period: 1));
Assert.Equal("period", ex.ParamName);
}
[Fact]
public void Constructor_NegativePeriod_ThrowsArgumentException()
{
var ex = Assert.Throws<ArgumentException>(() => new Gammadist(period: -1));
Assert.Equal("period", ex.ParamName);
}
[Fact]
public void Constructor_ZeroPeriod_ThrowsArgumentException()
{
var ex = Assert.Throws<ArgumentException>(() => new Gammadist(period: 0));
Assert.Equal("period", ex.ParamName);
}
// ─── B) Basic calculation ─────────────────────────────────────────────────
[Fact]
public void Update_ReturnsValidTValue()
{
var indicator = new Gammadist(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 Gammadist(alpha: 2.0, beta: 1.0, 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 Gammadist(period: 3);
var time = DateTime.UtcNow;
indicator.Update(new TValue(time, 50.0));
Assert.NotEqual(default, indicator.Last);
}
[Fact]
public void Name_ContainsGammadist()
{
var indicator = new Gammadist(alpha: 2.0, beta: 1.0, period: 14);
Assert.Contains("Gammadist", indicator.Name, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public void IsHot_Property_ReflectsWarmup()
{
var indicator = new Gammadist(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_AtMaxOfWindow_ReturnsNearOne()
{
var indicator = new Gammadist(alpha: 2.0, beta: 1.0, period: 5);
var time = DateTime.UtcNow;
double[] prices = { 100.0, 102.0, 98.0, 101.0, 110.0 }; // 110 is max
foreach (var p in prices)
{
indicator.Update(new TValue(time, p));
time = time.AddMinutes(1);
}
// When x=1.0 → xGamma=10.0, Gamma CDF well above 0.9 for α=2,β=1
Assert.True(indicator.Last.Value > 0.9, $"Expected near 1 but got {indicator.Last.Value}");
}
[Fact]
public void Update_AtMinOfWindow_ReturnsZero()
{
var indicator = new Gammadist(alpha: 2.0, beta: 1.0, period: 5);
var time = DateTime.UtcNow;
double[] prices = { 110.0, 102.0, 98.0, 101.0, 90.0 }; // 90 is min
foreach (var p in prices)
{
indicator.Update(new TValue(time, p));
time = time.AddMinutes(1);
}
Assert.Equal(0.0, indicator.Last.Value, Tolerance);
}
// ─── C) State + bar correction ────────────────────────────────────────────
[Fact]
public void Update_IsNewTrue_AdvancesState()
{
var indicator = new Gammadist(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 Gammadist(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 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 Gammadist(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 Gammadist(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 Gammadist(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 Gammadist(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_EqualsPeriod()
{
var indicator = new Gammadist(period: 25);
Assert.Equal(25, indicator.WarmupPeriod);
}
// ─── E) Robustness ────────────────────────────────────────────────────────
[Fact]
public void Update_NaN_UsesLastValidValue()
{
var indicator = new Gammadist(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 Gammadist(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 Gammadist(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 Gammadist(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_FlatRange_ReturnsCdfAtFive()
{
// When all values in window are identical, range=0 → xNorm=0.5 → xGamma=5.0
double alpha = 2.0;
double beta = 1.0;
var indicator = new Gammadist(alpha: alpha, beta: beta, period: 5);
var time = DateTime.UtcNow;
for (int i = 0; i < 10; i++)
{
indicator.Update(new TValue(time.AddMinutes(i), 100.0));
}
double expected = Gammadist.GammaCdf(5.0, alpha, beta);
Assert.Equal(expected, 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 Gammadist(period: period);
for (int i = 0; i < source.Count; i++)
{
streaming.Update(source[i]);
}
// Batch (TSeries)
var batch = Gammadist.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];
Gammadist.Batch(rawValues, spanOutput, period: period);
// Eventing
var eventResults = new List<double>();
var eventSource = new TSeries();
var eventIndicator = new Gammadist(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 Gammadist(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 = Gammadist.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>(() =>
Gammadist.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>(() =>
Gammadist.Batch(src, dst));
Assert.Equal("output", ex.ParamName);
}
[Fact]
public void Batch_Span_ZeroAlpha_ThrowsArgumentException()
{
double[] src = { 1.0, 2.0, 3.0 };
double[] dst = new double[3];
var ex = Assert.Throws<ArgumentException>(() =>
Gammadist.Batch(src, dst, alpha: 0.0));
Assert.Equal("alpha", ex.ParamName);
}
[Fact]
public void Batch_Span_ZeroBeta_ThrowsArgumentException()
{
double[] src = { 1.0, 2.0, 3.0 };
double[] dst = new double[3];
var ex = Assert.Throws<ArgumentException>(() =>
Gammadist.Batch(src, dst, beta: 0.0));
Assert.Equal("beta", 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>(() =>
Gammadist.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];
Gammadist.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];
Gammadist.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];
Gammadist.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];
Gammadist.Batch(src, spanOut, period: 14);
var streaming = new Gammadist(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 Gammadist(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 Gammadist(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 Gammadist(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: Alpha/Beta parameter effects ─────────────────────────────
[Fact]
public void DifferentAlpha_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 Gammadist(alpha: 1.0, beta: 1.0, period: 20);
var ind2 = new Gammadist(alpha: 2.0, beta: 1.0, period: 20);
var ind3 = new Gammadist(alpha: 5.0, beta: 1.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]);
}
// All outputs must be in [0, 1]
Assert.True(ind1.Last.Value >= 0.0 && ind1.Last.Value <= 1.0);
Assert.True(ind2.Last.Value >= 0.0 && ind2.Last.Value <= 1.0);
Assert.True(ind3.Last.Value >= 0.0 && ind3.Last.Value <= 1.0);
}
[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) = Gammadist.Calculate(bars.Close, period: 20);
Assert.Equal(count, results.Count);
Assert.True(instance.IsHot);
Assert.Equal(results[^1].Value, instance.Last.Value, Tolerance);
}
}
lib/numerics/gammadist/Gammadist.Validation.Tests.cs
+376
View File
@@ -0,0 +1,376 @@
using Xunit;
using MathNet.Numerics.Distributions;
namespace QuanTAlib.Tests;
/// <summary>
/// GammadistValidationTests — validates against known mathematical properties
/// of the Gamma Distribution CDF and against MathNet.Numerics Gamma.
/// Known-value tests call Gammadist.GammaCdf / StaticCdf directly (bypassing windowing)
/// so results are exact closed-form comparisons with tolerance 1e-9.
/// Note: MathNet Gamma(shape, rate) uses rate = 1/scale, so rate = 1/beta.
/// </summary>
public class GammadistValidationTests
{
private const double Tolerance = 1e-9;
private const double LooseTolerance = 1e-6;
// ─── Boundary: F(0; α, β) = 0 always ────────────────────────────────────
[Theory]
[InlineData(1.0, 1.0)]
[InlineData(2.0, 1.0)]
[InlineData(0.5, 2.0)]
[InlineData(5.0, 3.0)]
public void GammaCdf_AtZero_IsAlwaysZero(double alpha, double beta)
{
Assert.Equal(0.0, Gammadist.GammaCdf(0.0, alpha, beta), Tolerance);
}
[Theory]
[InlineData(-0.1, 1.0, 1.0)]
[InlineData(-1.0, 2.0, 1.0)]
[InlineData(-100.0, 5.0, 2.0)]
public void GammaCdf_Negative_IsAlwaysZero(double x, double alpha, double beta)
{
Assert.Equal(0.0, Gammadist.GammaCdf(x, alpha, beta), Tolerance);
}
// ─── Boundary: F(+∞; α, β) → 1 ──────────────────────────────────────────
[Theory]
[InlineData(1.0, 1.0, 0.9999)]
[InlineData(2.0, 1.0, 0.9999)]
[InlineData(5.0, 2.0, 0.999)]
public void GammaCdf_AtLargeX_ApproachesOne(double alpha, double beta, double minExpected)
{
double cdf = Gammadist.GammaCdf(1000.0, alpha, beta);
Assert.True(cdf > minExpected,
$"Gamma({alpha},{beta}) CDF at large x={cdf} should be > {minExpected}");
}
// ─── Known value: Gamma(1,1) = Exp(1), F(1;1,1) = 1 - e^(-1) ≈ 0.6321 ──
[Fact]
public void GammaCdf_Alpha1_Beta1_AtOne_EqualsExpDist()
{
// Gamma(α=1, β=1) = Exponential(λ=1): F(1) = 1 - e^(-1)
double expected = 1.0 - Math.Exp(-1.0); // ≈ 0.63212055882856
double actual = Gammadist.GammaCdf(1.0, 1.0, 1.0);
Assert.Equal(expected, actual, Tolerance);
}
[Fact]
public void GammaCdf_Alpha1_Beta2_AtTwo_EqualsExpDist()
{
// Gamma(α=1, β=2) = Exponential(λ=0.5): F(2) = 1 - e^(-2/2) = 1 - e^(-1)
double expected = 1.0 - Math.Exp(-1.0);
double actual = Gammadist.GammaCdf(2.0, 1.0, 2.0);
Assert.Equal(expected, actual, Tolerance);
}
// ─── MathNet.Numerics cross-validation ───────────────────────────────────
[Theory]
[InlineData(1.0, 1.0, 1.0)]
[InlineData(2.0, 2.0, 1.0)]
[InlineData(0.5, 0.5, 0.5)]
[InlineData(3.0, 2.0, 1.0)]
[InlineData(1.0, 5.0, 2.0)]
[InlineData(5.0, 3.0, 1.0)]
[InlineData(0.1, 1.0, 1.0)]
[InlineData(10.0, 4.0, 2.0)]
[InlineData(2.0, 1.5, 0.5)]
[InlineData(8.0, 2.0, 3.0)]
public void GammaCdf_VsMathNet_KnownValues(double x, double alpha, double beta)
{
// MathNet Gamma(shape, rate) where rate = 1/scale = 1/beta
var dist = new MathNet.Numerics.Distributions.Gamma(alpha, 1.0 / beta);
double expected = dist.CumulativeDistribution(x);
double actual = Gammadist.GammaCdf(x, alpha, beta);
Assert.Equal(expected, actual, Tolerance);
}
[Theory]
[InlineData(1.0, 1.0, 1.0)]
[InlineData(2.0, 2.0, 1.0)]
[InlineData(3.0, 3.0, 1.0)]
[InlineData(5.0, 2.0, 2.0)]
[InlineData(0.5, 1.5, 0.5)]
public void StaticCdf_VsMathNet_KnownValues(double x, double alpha, double beta)
{
var dist = new MathNet.Numerics.Distributions.Gamma(alpha, 1.0 / beta);
double expected = dist.CumulativeDistribution(x);
double actual = Gammadist.StaticCdf(x, alpha, beta);
Assert.Equal(expected, actual, Tolerance);
}
// ─── Monotonicity ─────────────────────────────────────────────────────────
[Theory]
[InlineData(1.0, 1.0)]
[InlineData(2.0, 1.0)]
[InlineData(0.5, 1.0)]
[InlineData(5.0, 2.0)]
[InlineData(2.0, 0.5)]
public void GammaCdf_MonotonicIncreasing(double alpha, double beta)
{
double prev = -1.0;
for (int i = 0; i <= 30; i++)
{
double x = i * 0.5;
double cdf = Gammadist.GammaCdf(x, alpha, beta);
Assert.True(cdf >= prev - LooseTolerance,
$"CDF not monotonic at x={x} (α={alpha}, β={beta}): got {cdf}, prev={prev}");
prev = cdf;
}
}
// ─── Output bounded [0, 1] with streaming indicator ──────────────────────
[Fact]
public void GammadistCdf_OutputBounded_Zero_To_One()
{
int count = 200;
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 73001);
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
var indicator = new Gammadist(alpha: 2.0, beta: 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 at xGamma = 5.0 / beta ─────────────────────────────
[Theory]
[InlineData(1.0, 1.0)]
[InlineData(2.0, 1.0)]
[InlineData(2.0, 0.5)]
[InlineData(5.0, 2.0)]
public void GammadistCdf_FlatRange_ReturnsCdfAtFive(double alpha, double beta)
{
var ind = new Gammadist(alpha, beta, period: 20);
var time = DateTime.UtcNow;
for (int i = 0; i < 20; i++)
{
ind.Update(new TValue(time.AddSeconds(i), 100.0));
}
// xNorm=0.5 → xGamma=5.0 → x/beta = 5/beta
double expected = Gammadist.GammaCdf(5.0, alpha, beta);
Assert.Equal(expected, ind.Last.Value, LooseTolerance);
}
// ─── Mean: E[Gamma(α,β)] = α*β; median CDF check ─────────────────────────
[Theory]
[InlineData(1.0, 1.0)] // mean = 1
[InlineData(2.0, 2.0)] // mean = 4
[InlineData(3.0, 1.0)] // mean = 3
public void GammaCdf_AtMean_IsNearExpected(double alpha, double beta)
{
double mean = alpha * beta;
// For alpha >= 1, CDF at mean is between 0.5 and 1 (shifted right of median)
double cdf = Gammadist.GammaCdf(mean, alpha, beta);
Assert.True(cdf > 0.3 && cdf < 1.0,
$"CDF at mean ({cdf}) should be in (0.3,1) for α={alpha}, β={beta}");
}
// ─── Shape shift: larger α shifts CDF right ───────────────────────────────
[Theory]
[InlineData(1.0, 5.0)]
[InlineData(2.0, 5.0)]
[InlineData(5.0, 5.0)]
public void GammaCdf_LargerAlpha_ShiftsCdfRight(double x, double beta)
{
// At the same x, larger α → lower CDF (mass shifted right)
double cdf1 = Gammadist.GammaCdf(x, 1.0, beta);
double cdf2 = Gammadist.GammaCdf(x, 3.0, beta);
double cdf3 = Gammadist.GammaCdf(x, 7.0, beta);
Assert.True(cdf1 >= cdf2 - LooseTolerance,
$"α=1 CDF={cdf1} should be >= α=3 CDF={cdf2} at x={x}");
Assert.True(cdf2 >= cdf3 - LooseTolerance,
$"α=3 CDF={cdf2} should be >= α=7 CDF={cdf3} at x={x}");
}
// ─── Scale shift: larger β stretches CDF right (same relative shape) ─────
[Fact]
public void GammaCdf_ScaleIdentity_Gamma_AlphaBeta_VsMathNet()
{
// F(x; α, β) = F(x/β; α, 1) — scaling identity
double alpha = 3.0, beta = 2.0, x = 6.0;
double direct = Gammadist.GammaCdf(x, alpha, beta);
double scaled = Gammadist.GammaCdf(x / beta, alpha, 1.0);
Assert.Equal(direct, scaled, Tolerance);
}
// ─── LnGamma internal correctness ────────────────────────────────────────
[Theory]
[InlineData(1.0, 0.0)] // Γ(1) = 1 → ln(1) = 0
[InlineData(2.0, 0.0)] // Γ(2) = 1! = 1 → ln(1) = 0
[InlineData(3.0, 0.6931471805599453)] // Γ(3) = 2! = 2 → ln(2)
[InlineData(4.0, 1.791759469228327)] // Γ(4) = 3! = 6 → ln(6)
[InlineData(5.0, 3.178053830347946)] // Γ(5) = 4! = 24 → ln(24)
public void LnGamma_IntegerArguments_MatchKnownValues(double z, double expected)
{
double actual = Gammadist.LnGamma(z);
Assert.Equal(expected, actual, 1e-10);
}
// ─── 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: 73002);
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 = Gammadist.Batch(bars.Close, alpha: 2.0, beta: 1.0, period: 30);
double[] spanResult = new double[count];
Gammadist.Batch(rawValues, spanResult, alpha: 2.0, beta: 1.0, period: 30);
for (int i = 0; i < count; i++)
{
Assert.Equal(tseriesResult[i].Value, spanResult[i], Tolerance);
}
}
// ─── Streaming convergence ────────────────────────────────────────────────
[Fact]
public void GammadistCdf_HighPeriod_StillConverges()
{
int period = 200;
var indicator = new Gammadist(alpha: 2.0, beta: 1.0, period: period);
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 73003);
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(1.0, 1.0, 5)]
[InlineData(2.0, 1.0, 14)]
[InlineData(0.5, 0.5, 10)]
[InlineData(5.0, 2.0, 20)]
[InlineData(3.0, 0.5, 30)]
public void GammadistCdf_ParameterCombos_OutputBounded(double alpha, double beta, int period)
{
int count = period + 50;
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 73004 + (int)(alpha * 100));
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
var indicator = new Gammadist(alpha, beta, 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} (α={alpha}, β={beta}, period={period})");
}
}
// ─── Large dataset stable ─────────────────────────────────────────────────
[Fact]
public void GammadistCdf_LargeDataset_Stable()
{
int count = 2000;
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 73005);
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
var indicator = new Gammadist(alpha: 2.0, beta: 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}");
}
}
// ─── Extreme prices don't blow up ─────────────────────────────────────────
[Fact]
public void GammadistCdf_ExtremePrices_StillInRange()
{
var indicator = new Gammadist(alpha: 2.0, beta: 1.0, period: 20);
var time = DateTime.UtcNow;
for (int i = 0; i < 20; i++)
{
double price = (i % 2 == 0) ? 1e10 : 1e-10;
indicator.Update(new TValue(time.AddMinutes(i), price));
double v = indicator.Last.Value;
Assert.True(v >= 0.0 && v <= 1.0, $"Out of range at {i}: {v}");
}
}
// ─── Multiple points all match MathNet ───────────────────────────────────
[Fact]
public void GammaCdf_MultiplePoints_AllMatchMathNet()
{
double alpha = 2.0, beta = 1.0;
var dist = new MathNet.Numerics.Distributions.Gamma(alpha, 1.0 / beta);
double[] testX = { 0.0, 0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0 };
foreach (double x in testX)
{
double expected = dist.CumulativeDistribution(x);
double actual = Gammadist.GammaCdf(x, alpha, beta);
Assert.Equal(expected, actual, Tolerance);
}
}
// ─── RegularizedIncompleteGamma internal tests ────────────────────────────
[Fact]
public void RegularizedIncompleteGamma_AtZero_IsZero()
{
double lnGammaA = Gammadist.LnGamma(2.0);
double result = Gammadist.RegularizedIncompleteGamma(2.0, 0.0, lnGammaA);
Assert.Equal(0.0, result, Tolerance);
}
[Theory]
[InlineData(1.0, 1.0)] // P(1, 1) = 1 - e^(-1)
[InlineData(2.0, 2.0)] // vs MathNet
[InlineData(3.0, 1.5)] // vs MathNet
public void RegularizedIncompleteGamma_VsMathNet(double a, double x)
{
var dist = new MathNet.Numerics.Distributions.Gamma(a, 1.0);
double expected = dist.CumulativeDistribution(x);
double lnGammaA = Gammadist.LnGamma(a);
double actual = Gammadist.RegularizedIncompleteGamma(a, x, lnGammaA);
Assert.Equal(expected, actual, Tolerance);
}
}
lib/numerics/gammadist/Gammadist.cs
+440
View File
@@ -0,0 +1,440 @@
// GAMMADIST: Gamma Distribution CDF
// Applies the regularized incomplete gamma function P(α, x/β) to a min-max
// normalized price series over a rolling lookback window.
// Pipeline: MinMax normalization → [0,10] scaling → Lanczos log-gamma → series/CF evaluation.
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace QuanTAlib;
/// <summary>
/// GAMMADIST: Gamma Distribution CDF
/// Computes F(x; α, β) = P(α, x/β) — the regularized lower incomplete gamma
/// function — applied to a min-max normalized price series over a rolling window.
/// </summary>
/// <remarks>
/// Key properties:
/// - Output always in [0, 1]
/// - Rolling window tracks min/max for normalization; flat range returns F(5; α, β)
/// - α (shape) controls CDF form: α=1 → exponential decay, α&gt;1 → S-curve
/// - β (scale) controls rise speed: smaller β → faster saturation
/// - Series expansion for x &lt; α+1; Lentz continued fraction for x ≥ α+1
/// - Lanczos log-gamma (g=7, 9 coefficients) for numerical accuracy to 1e-15
/// - NaN/Infinity inputs use last-valid-value substitution
/// </remarks>
[SkipLocalsInit]
public sealed class Gammadist : AbstractBase
{
private readonly int _period;
private readonly double _alpha;
private readonly double _beta;
private readonly double _lnGammaAlpha;
private readonly RingBuffer _buffer;
// Lanczos g=7, 9 coefficients (Numerical Recipes 3rd Ed., Table 6.1)
private static ReadOnlySpan<double> LanczosCoeff =>
[
0.99999999999980993,
676.5203681218851,
-1259.1392167224028,
771.32342877765313,
-176.61502916214059,
12.507343278686905,
-0.13857109526572012,
9.9843695780195716e-6,
1.5056327351493116e-7
];
[StructLayout(LayoutKind.Auto)]
private record struct State(double LastValid);
private State _state, _p_state;
public override bool IsHot => _buffer.Count >= _period;
/// <summary>
/// Initializes a new Gammadist indicator.
/// </summary>
/// <param name="alpha">Shape parameter α &gt; 0 (default 2.0)</param>
/// <param name="beta">Scale parameter β &gt; 0 (default 1.0)</param>
/// <param name="period">Lookback window for min-max normalization (default 14)</param>
public Gammadist(double alpha = 2.0, double beta = 1.0, int period = 14)
{
if (alpha <= 0.0)
{
throw new ArgumentException("Alpha must be > 0", nameof(alpha));
}
if (beta <= 0.0)
{
throw new ArgumentException("Beta must be > 0", nameof(beta));
}
if (period < 2)
{
throw new ArgumentException("Period must be >= 2", nameof(period));
}
_alpha = alpha;
_beta = beta;
_period = period;
_lnGammaAlpha = LnGamma(alpha);
_buffer = new RingBuffer(period);
Name = $"Gammadist({alpha:F2},{beta:F2},{period})";
WarmupPeriod = period;
_state = new State(0.5);
_p_state = _state;
}
/// <summary>
/// Initializes a new Gammadist indicator with source for event-based chaining.
/// </summary>
/// <param name="source">Source indicator for chaining</param>
/// <param name="alpha">Shape parameter α &gt; 0 (default 2.0)</param>
/// <param name="beta">Scale parameter β &gt; 0 (default 1.0)</param>
/// <param name="period">Lookback window (default 14)</param>
public Gammadist(ITValuePublisher source, double alpha = 2.0, double beta = 1.0, int period = 14)
: this(alpha, beta, period)
{
source.Pub += HandleUpdate;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void HandleUpdate(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
/// <summary>
/// Lanczos log-gamma approximation (g=7, 9 coefficients).
/// Accurate to ~15 digits for z > 0.5; uses reflection formula for z &lt; 0.5.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double LnGamma(double z)
{
if (z < 0.5)
{
return Math.Log(Math.PI / Math.Sin(Math.PI * z)) - LnGamma(1.0 - z);
}
z -= 1.0;
ReadOnlySpan<double> c = LanczosCoeff;
double x = c[0];
for (int i = 1; i < 9; i++)
{
x += c[i] / (z + i);
}
double t = z + 7.5;
return Math.FusedMultiplyAdd(z + 0.5, Math.Log(t), 0.5 * Math.Log(2.0 * Math.PI) - t + Math.Log(x));
}
/// <summary>
/// Series expansion for regularized lower incomplete gamma P(a, x).
/// Converges for x &lt; a + 1.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static double GammaSeries(double a, double x, double lnGammaA)
{
const int MaxIter = 200;
const double Eps = 1e-12;
double ap = a;
double sum = 1.0 / a;
double del = 1.0 / a;
for (int n = 0; n < MaxIter; n++)
{
ap += 1.0;
del *= x / ap;
sum += del;
if (Math.Abs(del) < Math.Abs(sum) * Eps)
{
break;
}
}
return sum * Math.Exp(-x + a * Math.Log(x) - lnGammaA);
}
/// <summary>
/// Lentz continued fraction for regularized upper incomplete gamma Q(a, x) = 1 - P(a, x).
/// Converges for x ≥ a + 1.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static double GammaCF(double a, double x, double lnGammaA)
{
const int MaxIter = 200;
const double Eps = 1e-12;
const double FpMin = 1e-300;
double b = x + 1.0 - a;
double c = 1.0 / FpMin;
double d = 1.0 / b;
double h = d;
for (int i = 1; i <= MaxIter; i++)
{
double an = -(double)i * (i - a);
b += 2.0;
d = Math.FusedMultiplyAdd(an, d, b);
if (Math.Abs(d) < FpMin)
{
d = FpMin;
}
c = b + an / c;
if (Math.Abs(c) < FpMin)
{
c = FpMin;
}
d = 1.0 / d;
double del = d * c;
h *= del;
if (Math.Abs(del - 1.0) < Eps)
{
break;
}
}
return Math.Exp(-x + a * Math.Log(x) - lnGammaA) * h;
}
/// <summary>
/// Regularized lower incomplete gamma function P(a, x) = γ(a,x)/Γ(a).
/// Uses series for x &lt; a+1; complement of CF for x ≥ a+1.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double RegularizedIncompleteGamma(double a, double x, double lnGammaA)
{
if (x <= 0.0)
{
return 0.0;
}
if (x < a + 1.0)
{
return GammaSeries(a, x, lnGammaA);
}
return 1.0 - GammaCF(a, x, lnGammaA);
}
/// <summary>
/// Gamma Distribution CDF: F(x; α, β) = P(α, x/β).
/// Returns 0 for x ≤ 0.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double GammaCdf(double x, double alpha, double beta)
{
if (x <= 0.0)
{
return 0.0;
}
double lnGammaA = LnGamma(alpha);
return RegularizedIncompleteGamma(alpha, x / beta, lnGammaA);
}
/// <summary>
/// Pure static CDF helper — identical to <see cref="GammaCdf"/> with an explicit name
/// for downstream consumers and validation tests.
/// </summary>
public static double StaticCdf(double x, double alpha, double beta) => GammaCdf(x, alpha, beta);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static (double min, double max) FindMinMax(ReadOnlySpan<double> values)
{
if (values.Length == 0)
{
return (double.MaxValue, double.MinValue);
}
double min = values[0];
double max = values[0];
for (int i = 1; i < values.Length; i++)
{
double v = values[i];
if (v < min)
{
min = v;
}
if (v > max)
{
max = v;
}
}
return (min, max);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override TValue Update(TValue input, bool isNew = true)
{
if (isNew)
{
_p_state = _state;
}
else
{
_state = _p_state;
}
double value = input.Value;
double result;
if (double.IsFinite(value))
{
_buffer.Add(value, isNew);
var (min, max) = FindMinMax(_buffer.GetSpan());
double range = max - min;
// Flat range → use midpoint 0.5; map [0,1] → [0,10] for useful CDF spread
double xNorm = range > 0.0 ? (value - min) / range : 0.5;
double xGamma = xNorm * 10.0;
result = RegularizedIncompleteGamma(_alpha, xGamma / _beta, _lnGammaAlpha);
_state = new State(result);
}
else
{
result = _state.LastValid;
}
Last = new TValue(input.Time, result);
PubEvent(Last, isNew);
return Last;
}
public override TSeries Update(TSeries source)
{
var result = new TSeries(source.Count);
ReadOnlySpan<double> values = source.Values;
ReadOnlySpan<long> times = source.Times;
for (int i = 0; i < source.Count; i++)
{
var tv = Update(new TValue(new DateTime(times[i], DateTimeKind.Utc), values[i]), true);
result.Add(tv, true);
}
return result;
}
public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
{
TimeSpan interval = step ?? TimeSpan.FromSeconds(1);
DateTime time = DateTime.UtcNow - (interval * source.Length);
for (int i = 0; i < source.Length; i++)
{
Update(new TValue(time, source[i]), true);
time += interval;
}
}
public static TSeries Batch(TSeries source, double alpha = 2.0, double beta = 1.0, int period = 14)
{
var indicator = new Gammadist(alpha, beta, period);
return indicator.Update(source);
}
/// <summary>
/// Calculates Gamma Distribution CDF over a span of values.
/// Uses a sliding window min-max normalization identical to the streaming path.
/// </summary>
public static void Batch(
ReadOnlySpan<double> source, Span<double> output,
double alpha = 2.0, double beta = 1.0, int period = 14)
{
if (source.Length == 0)
{
throw new ArgumentException("Source cannot be empty", nameof(source));
}
if (output.Length < source.Length)
{
throw new ArgumentException("Output length must be >= source length", nameof(output));
}
if (alpha <= 0.0)
{
throw new ArgumentException("Alpha must be > 0", nameof(alpha));
}
if (beta <= 0.0)
{
throw new ArgumentException("Beta must be > 0", nameof(beta));
}
if (period < 2)
{
throw new ArgumentException("Period must be >= 2", nameof(period));
}
double lnGammaA = LnGamma(alpha);
double lastValid = 0.5;
for (int i = 0; i < source.Length; i++)
{
double val = source[i];
if (!double.IsFinite(val))
{
output[i] = lastValid;
continue;
}
int start = Math.Max(0, i - period + 1);
double min = double.PositiveInfinity;
double max = double.NegativeInfinity;
for (int j = start; j <= i; j++)
{
double v = source[j];
if (double.IsFinite(v))
{
if (v < min)
{
min = v;
}
if (v > max)
{
max = v;
}
}
}
if (!double.IsFinite(min) || !double.IsFinite(max))
{
output[i] = lastValid;
continue;
}
double range = max - min;
double xNorm = range > 0.0 ? (val - min) / range : 0.5;
double xGamma = xNorm * 10.0;
double result = RegularizedIncompleteGamma(alpha, xGamma / beta, lnGammaA);
lastValid = result;
output[i] = result;
}
}
public static (TSeries Results, Gammadist Indicator) Calculate(
TSeries source, double alpha = 2.0, double beta = 1.0, int period = 14)
{
var indicator = new Gammadist(alpha, beta, period);
TSeries results = indicator.Update(source);
return (results, indicator);
}
public override void Reset()
{
_buffer.Clear();
_state = new State(0.5);
_p_state = _state;
Last = default;
}
}