mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-21 12:08:05 +00:00
Add Savitzky-Golay Moving Average (SGMA) Indicator Implementation
- Implemented SgmaIndicator class in C# with properties for Period, Degree, and Source. - Added unit tests for SgmaIndicator covering constructor defaults, initialization, and various update scenarios. - Created a new Quantower adapter for the SGMA indicator, including input parameters and line series setup. - Removed legacy SGMA implementation and tests to streamline the codebase. - Updated project files to include new indicator and tests in the build process. - Generated a missing indicators report and outlined a plan for oscillator documentation rewrite.
This commit is contained in:
Miha Kralj
@@ -0,0 +1,547 @@
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class GrangerConstructorTests
|
||||
{
|
||||
[Fact]
|
||||
public void Constructor_WithValidPeriod_SetsProperties()
|
||||
{
|
||||
var indicator = new Granger(10);
|
||||
|
||||
Assert.Equal("Granger(10)", indicator.Name);
|
||||
Assert.Equal(11, indicator.WarmupPeriod); // period + 1
|
||||
Assert.False(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithDefaultPeriod_UsesTwenty()
|
||||
{
|
||||
var indicator = new Granger();
|
||||
|
||||
Assert.Equal("Granger(20)", indicator.Name);
|
||||
Assert.Equal(21, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithPeriodThree_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Granger(3));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithPeriodTwo_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Granger(2));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithPeriodZero_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Granger(0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithNegativePeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Granger(-5));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
}
|
||||
|
||||
public class GrangerBasicTests
|
||||
{
|
||||
private const int DefaultPeriod = 20;
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsTValue()
|
||||
{
|
||||
var indicator = new Granger(DefaultPeriod);
|
||||
|
||||
var result = indicator.Update(100.0, 100.0);
|
||||
|
||||
Assert.IsType<TValue>(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsNaN_BeforeWarmup()
|
||||
{
|
||||
var indicator = new Granger(DefaultPeriod);
|
||||
|
||||
// First few updates should return NaN until warmup
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
var result = indicator.Update(100.0 + i, 100.0 + i);
|
||||
Assert.True(double.IsNaN(result.Value));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsFiniteValue_AfterWarmup()
|
||||
{
|
||||
var indicator = new Granger(DefaultPeriod);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.1, seed: 12345);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.1, seed: 54321);
|
||||
|
||||
// Feed enough data to warm up
|
||||
for (int i = 0; i < DefaultPeriod + 5; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close);
|
||||
}
|
||||
|
||||
Assert.True(double.IsFinite(indicator.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IsHot_BecomesTrueAfterWarmup()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 12345);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 54321);
|
||||
|
||||
Assert.False(indicator.IsHot);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close);
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_SingleInput_ThrowsNotSupported()
|
||||
{
|
||||
var indicator = new Granger();
|
||||
|
||||
Assert.Throws<NotSupportedException>(() => indicator.Update(new TValue(DateTime.UtcNow, 100.0)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_TSeries_ThrowsNotSupported()
|
||||
{
|
||||
var indicator = new Granger();
|
||||
var series = new TSeries(10);
|
||||
|
||||
Assert.Throws<NotSupportedException>(() => indicator.Update(series));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_FStatistic_IsNonNegative()
|
||||
{
|
||||
var indicator = new Granger(10);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.2, seed: 12345);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.2, seed: 54321);
|
||||
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
var result = indicator.Update(gbmY.Next().Close, gbmX.Next().Close);
|
||||
Assert.True(double.IsNaN(result.Value) || result.Value >= 0.0,
|
||||
$"F-statistic should be non-negative or NaN, got {result.Value}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class GrangerStateCorrectionTests
|
||||
{
|
||||
[Fact]
|
||||
public void Update_IsNew_True_AdvancesState()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
TValue prev = default;
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
prev = indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
var next = indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
|
||||
// New bar should advance state and potentially produce different value
|
||||
Assert.NotEqual(0.0, next.Value + prev.Value); // Not both zero
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IsNew_False_RewritesCurrentBar()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
// Warm up
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
// New bar
|
||||
double y1 = gbmY.Next().Close;
|
||||
double x1 = gbmX.Next().Close;
|
||||
var result1 = indicator.Update(y1, x1, isNew: true);
|
||||
|
||||
// Correct with same values
|
||||
var result2 = indicator.Update(y1, x1, isNew: false);
|
||||
|
||||
Assert.Equal(result1.Value, result2.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IterativeCorrections_RestoreState()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
// Warm up
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
// New bar
|
||||
double y1 = gbmY.Next().Close;
|
||||
double x1 = gbmX.Next().Close;
|
||||
indicator.Update(y1, x1, isNew: true);
|
||||
|
||||
// Multiple corrections converge
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
indicator.Update(y1 + i * 0.01, x1 + i * 0.01, isNew: false);
|
||||
}
|
||||
|
||||
var final1 = indicator.Update(y1, x1, isNew: false);
|
||||
var final2 = indicator.Update(y1, x1, isNew: false);
|
||||
|
||||
Assert.Equal(final1.Value, final2.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
// Warm up
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
|
||||
indicator.Reset();
|
||||
|
||||
Assert.False(indicator.IsHot);
|
||||
Assert.Equal(default, indicator.Last);
|
||||
}
|
||||
}
|
||||
|
||||
public class GrangerWarmupTests
|
||||
{
|
||||
[Fact]
|
||||
public void IsHot_FlipsWhenWindowFull()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
// Need period+1 bars for IsHot (1 for lag + period for window)
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
Assert.False(indicator.IsHot);
|
||||
}
|
||||
|
||||
// After period+1 bars, should be hot
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
Assert.True(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WarmupPeriod_IsPeriodPlusOne()
|
||||
{
|
||||
var indicator = new Granger(10);
|
||||
Assert.Equal(11, indicator.WarmupPeriod);
|
||||
}
|
||||
}
|
||||
|
||||
public class GrangerRobustnessTests
|
||||
{
|
||||
[Fact]
|
||||
public void Update_WithNaN_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
// Warm up
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
_ = indicator.Last;
|
||||
|
||||
// Feed NaN - should not propagate to output
|
||||
var result = indicator.Update(double.NaN, double.NaN, isNew: true);
|
||||
Assert.True(double.IsFinite(result.Value) || double.IsNaN(result.Value));
|
||||
// Key: should not throw
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_WithInfinity_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
// Warm up
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
// Feed Infinity - should not throw or produce Infinity
|
||||
var result = indicator.Update(double.PositiveInfinity, double.NegativeInfinity, isNew: true);
|
||||
Assert.False(double.IsInfinity(result.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_BatchNaN_DoesNotThrow()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
|
||||
// Feed all NaN - should not throw
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
var result = indicator.Update(double.NaN, double.NaN, isNew: true);
|
||||
Assert.False(double.IsInfinity(result.Value));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_ConstantSeries_ReturnsNaNOrZero()
|
||||
{
|
||||
// Constant series has zero variance, should handle gracefully
|
||||
var indicator = new Granger(5);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
var result = indicator.Update(100.0, 100.0, isNew: true);
|
||||
Assert.True(double.IsNaN(result.Value) || result.Value >= 0.0,
|
||||
$"Should handle constant series gracefully, got {result.Value}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class GrangerConsistencyTests
|
||||
{
|
||||
[Fact]
|
||||
public void BatchCalc_MatchesStreaming()
|
||||
{
|
||||
const int period = 10;
|
||||
const int count = 100;
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.2, seed: 12345);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.03, sigma: 0.15, seed: 54321);
|
||||
|
||||
var seriesY = new TSeries(count);
|
||||
var seriesX = new TSeries(count);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
var barY = gbmY.Next(isNew: true);
|
||||
var barX = gbmX.Next(isNew: true);
|
||||
seriesY.Add(new TValue(barY.Time, barY.Close));
|
||||
seriesX.Add(new TValue(barX.Time, barX.Close));
|
||||
}
|
||||
|
||||
// Batch calculation
|
||||
var batchResults = Granger.Batch(seriesY, seriesX, period);
|
||||
|
||||
// Streaming calculation
|
||||
var streamIndicator = new Granger(period);
|
||||
var streamResults = new TSeries(count);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
streamResults.Add(streamIndicator.Update(
|
||||
new TValue(seriesY.Times[i], seriesY.Values[i]),
|
||||
new TValue(seriesX.Times[i], seriesX.Values[i]),
|
||||
isNew: true));
|
||||
}
|
||||
|
||||
// Compare
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
if (double.IsNaN(batchResults.Values[i]) && double.IsNaN(streamResults.Values[i]))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
Assert.Equal(batchResults.Values[i], streamResults.Values[i], 10);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SpanCalc_MatchesStreaming()
|
||||
{
|
||||
const int period = 10;
|
||||
const int count = 100;
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.2, seed: 12345);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.03, sigma: 0.15, seed: 54321);
|
||||
|
||||
double[] yValues = new double[count];
|
||||
double[] xValues = new double[count];
|
||||
double[] output = new double[count];
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
yValues[i] = gbmY.Next(isNew: true).Close;
|
||||
xValues[i] = gbmX.Next(isNew: true).Close;
|
||||
}
|
||||
|
||||
// Span calculation
|
||||
Granger.Batch(yValues.AsSpan(), xValues.AsSpan(), output.AsSpan(), period);
|
||||
|
||||
// Streaming calculation
|
||||
var gbmY2 = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.2, seed: 12345);
|
||||
var gbmX2 = new GBM(startPrice: 100.0, mu: 0.03, sigma: 0.15, seed: 54321);
|
||||
var streamIndicator = new Granger(period);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
var result = streamIndicator.Update(gbmY2.Next(isNew: true).Close, gbmX2.Next(isNew: true).Close, isNew: true);
|
||||
if (double.IsNaN(output[i]) && double.IsNaN(result.Value))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
Assert.Equal(output[i], result.Value, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class GrangerSpanTests
|
||||
{
|
||||
[Fact]
|
||||
public void Batch_Span_MismatchedLengths_Throws()
|
||||
{
|
||||
double[] y = new double[10];
|
||||
double[] x = new double[5];
|
||||
double[] output = new double[10];
|
||||
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Granger.Batch(y.AsSpan(), x.AsSpan(), output.AsSpan(), 4));
|
||||
Assert.Equal("seriesX", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_OutputLengthMismatch_Throws()
|
||||
{
|
||||
double[] y = new double[10];
|
||||
double[] x = new double[10];
|
||||
double[] output = new double[5];
|
||||
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Granger.Batch(y.AsSpan(), x.AsSpan(), output.AsSpan(), 4));
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_InvalidPeriod_Throws()
|
||||
{
|
||||
double[] y = new double[10];
|
||||
double[] x = new double[10];
|
||||
double[] output = new double[10];
|
||||
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Granger.Batch(y.AsSpan(), x.AsSpan(), output.AsSpan(), 3));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_TSeries_MismatchedLengths_Throws()
|
||||
{
|
||||
var seriesY = new TSeries(10);
|
||||
var seriesX = new TSeries(5);
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
seriesY.Add(new TValue(DateTime.UtcNow, i));
|
||||
}
|
||||
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
seriesX.Add(new TValue(DateTime.UtcNow, i));
|
||||
}
|
||||
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
Granger.Batch(seriesY, seriesX, 4));
|
||||
Assert.Equal("seriesX", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Span_HandlesNaN()
|
||||
{
|
||||
double[] y = new double[20];
|
||||
double[] x = new double[20];
|
||||
double[] output = new double[20];
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
y[i] = double.NaN;
|
||||
x[i] = double.NaN;
|
||||
}
|
||||
|
||||
// Should not throw
|
||||
Granger.Batch(y.AsSpan(), x.AsSpan(), output.AsSpan(), 5);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
Assert.False(double.IsInfinity(output[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class GrangerEventTests
|
||||
{
|
||||
[Fact]
|
||||
public void Pub_FiresOnUpdate()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
int eventCount = 0;
|
||||
|
||||
indicator.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
|
||||
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
Assert.Equal(10, eventCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Pub_EventChaining_Works()
|
||||
{
|
||||
var indicator = new Granger(5);
|
||||
var receivedValues = new List<double>();
|
||||
|
||||
indicator.Pub += (object? sender, in TValueEventArgs args) => receivedValues.Add(args.Value.Value);
|
||||
|
||||
var gbmY = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 42);
|
||||
var gbmX = new GBM(startPrice: 100.0, mu: 0.0, sigma: 0.1, seed: 84);
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(gbmY.Next().Close, gbmX.Next().Close, isNew: true);
|
||||
}
|
||||
|
||||
Assert.Equal(10, receivedValues.Count);
|
||||
// All received values should match Last at time of emission
|
||||
Assert.Equal(indicator.Last.Value, receivedValues[^1]);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user