mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-25 22:08:05 +00:00
docs: remove C# Implementation Considerations sections, clean up temp scripts, reorganize test files
- Remove 'C# Implementation Considerations' sections from 34 indicator .md files - Delete 29 temp PowerShell scripts (_fix_mojibake.ps1, _hex_scan.ps1, etc.) - Move test files into tests/ subdirectories for consistent project structure - Add trader-focused bullet points to indicator documentation
This commit is contained in:
Miha Kralj
@@ -0,0 +1,499 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// A) Constructor Validation
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevConstructorTests
|
||||
{
|
||||
[Fact]
|
||||
public void Constructor_PeriodZero_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new MeanDev(0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativePeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new MeanDev(-1));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_Period1_Works()
|
||||
{
|
||||
var md = new MeanDev(1);
|
||||
Assert.Equal("MeanDev(1)", md.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ValidPeriod_SetsName()
|
||||
{
|
||||
var md = new MeanDev(14);
|
||||
Assert.Equal("MeanDev(14)", md.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ValidPeriod_SetsWarmupPeriod()
|
||||
{
|
||||
var md = new MeanDev(14);
|
||||
Assert.Equal(14, md.WarmupPeriod);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// B) Basic Calculation
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevBasicTests
|
||||
{
|
||||
[Fact]
|
||||
public void Update_ReturnsTValue()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
var result = md.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.IsType<TValue>(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_LastAccessible()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
md.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.True(double.IsFinite(md.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_SingleValue_MeanDevIsZero()
|
||||
{
|
||||
// Single value: no deviation from itself
|
||||
var md = new MeanDev(1);
|
||||
md.Update(new TValue(DateTime.UtcNow, 42.0));
|
||||
Assert.Equal(0.0, md.Last.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_ConstantSeries_MeanDevIsZero()
|
||||
{
|
||||
// All values equal → mean = value, |x - mean| = 0 for all
|
||||
var md = new MeanDev(10);
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, 50.0));
|
||||
}
|
||||
Assert.Equal(0.0, md.Last.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_TwoValues_KnownResult()
|
||||
{
|
||||
// Values {1, 3}: mean=2, MD = (|1-2| + |3-2|)/2 = 1.0
|
||||
var md = new MeanDev(2);
|
||||
md.Update(new TValue(DateTime.UtcNow, 1.0));
|
||||
md.Update(new TValue(DateTime.UtcNow, 3.0));
|
||||
Assert.Equal(1.0, md.Last.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_MeanDevAlwaysNonNegative()
|
||||
{
|
||||
var md = new MeanDev(14);
|
||||
var gbm = new GBM();
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
md.Update(new TValue(bar.Time, bar.Close));
|
||||
Assert.True(md.Last.Value >= 0.0, $"MeanDev was negative at bar {i}: {md.Last.Value}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_KnownWindow_Manual()
|
||||
{
|
||||
// Window {2, 4, 6}: mean=4, MD = (2+0+2)/3 = 4/3
|
||||
var md = new MeanDev(3);
|
||||
md.Update(new TValue(DateTime.UtcNow, 2.0));
|
||||
md.Update(new TValue(DateTime.UtcNow, 4.0));
|
||||
md.Update(new TValue(DateTime.UtcNow, 6.0));
|
||||
Assert.Equal(4.0 / 3.0, md.Last.Value, 10);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// C) State + Bar Correction
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevStateTests
|
||||
{
|
||||
[Fact]
|
||||
public void IsNew_True_AdvancesState()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, i * 10.0));
|
||||
}
|
||||
double after5 = md.Last.Value;
|
||||
|
||||
md.Update(new TValue(DateTime.UtcNow, 100.0), isNew: true);
|
||||
Assert.NotEqual(after5, md.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsNew_False_UpdatesWithoutAdvancing()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, i * 10.0));
|
||||
}
|
||||
|
||||
// Set bar: initial value
|
||||
md.Update(new TValue(DateTime.UtcNow, 50.0), isNew: true);
|
||||
double afterNew = md.Last.Value;
|
||||
|
||||
// Correct the same bar
|
||||
md.Update(new TValue(DateTime.UtcNow, 60.0), isNew: false);
|
||||
Assert.NotEqual(afterNew, md.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IterativeCorrections_RestoreOriginalState()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, (i + 1) * 10.0));
|
||||
}
|
||||
double expected = md.Last.Value;
|
||||
_ = expected; // value validated via subsequent assertion
|
||||
|
||||
// Start a new bar with value that will be corrected repeatedly
|
||||
md.Update(new TValue(DateTime.UtcNow, 999.0), isNew: true);
|
||||
md.Update(new TValue(DateTime.UtcNow, 888.0), isNew: false);
|
||||
md.Update(new TValue(DateTime.UtcNow, 777.0), isNew: false);
|
||||
// Correct back to the "original" new bar value
|
||||
md.Update(new TValue(DateTime.UtcNow, 60.0), isNew: false);
|
||||
|
||||
// Now start ANOTHER new bar
|
||||
md.Update(new TValue(DateTime.UtcNow, 60.0), isNew: true);
|
||||
|
||||
// Not asserting exact value — just that it is finite and non-negative
|
||||
Assert.True(double.IsFinite(md.Last.Value));
|
||||
Assert.True(md.Last.Value >= 0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, i * 5.0));
|
||||
}
|
||||
|
||||
md.Reset();
|
||||
|
||||
Assert.False(md.IsHot);
|
||||
Assert.Equal(default, md.Last);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// D) Warmup / IsHot
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevWarmupTests
|
||||
{
|
||||
[Fact]
|
||||
public void IsHot_FalseBeforePeriodBars()
|
||||
{
|
||||
var md = new MeanDev(10);
|
||||
for (int i = 0; i < 9; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, i + 1.0));
|
||||
Assert.False(md.IsHot, $"IsHot should be false at bar {i + 1}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_TrueAfterPeriodBars()
|
||||
{
|
||||
var md = new MeanDev(10);
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, i + 1.0));
|
||||
}
|
||||
Assert.True(md.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_IsPeriodDependent()
|
||||
{
|
||||
var md5 = new MeanDev(5);
|
||||
var md20 = new MeanDev(20);
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
md5.Update(new TValue(DateTime.UtcNow, i + 1.0));
|
||||
md20.Update(new TValue(DateTime.UtcNow, i + 1.0));
|
||||
}
|
||||
|
||||
Assert.True(md5.IsHot);
|
||||
Assert.False(md20.IsHot);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// E) Robustness (NaN / Infinity)
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevRobustnessTests
|
||||
{
|
||||
[Fact]
|
||||
public void NaN_Input_UsesLastValidValue()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, 10.0));
|
||||
}
|
||||
md.Update(new TValue(DateTime.UtcNow, double.NaN));
|
||||
Assert.True(double.IsFinite(md.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PositiveInfinity_Input_UsesLastValid()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, 10.0));
|
||||
}
|
||||
|
||||
md.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity));
|
||||
Assert.True(double.IsFinite(md.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NegativeInfinity_Input_UsesLastValid()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, 10.0));
|
||||
}
|
||||
|
||||
md.Update(new TValue(DateTime.UtcNow, double.NegativeInfinity));
|
||||
Assert.True(double.IsFinite(md.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MultipleNaN_ContinuesWithLastValid()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, 20.0));
|
||||
}
|
||||
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, double.NaN));
|
||||
Assert.True(double.IsFinite(md.Last.Value));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// F) Consistency — all 4 API modes must agree
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevConsistencyTests
|
||||
{
|
||||
[Fact]
|
||||
public void AllModes_ProduceSameResult()
|
||||
{
|
||||
const int period = 14;
|
||||
const int count = 200;
|
||||
var gbm = new GBM(seed: 42);
|
||||
var bars = new List<TBar>();
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
bars.Add(gbm.Next());
|
||||
}
|
||||
|
||||
var series = new TSeries();
|
||||
foreach (var bar in bars)
|
||||
{
|
||||
series.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
// 1. Batch (TSeries)
|
||||
var batchResult = MeanDev.Batch(series, period);
|
||||
double expected = batchResult.Last.Value;
|
||||
|
||||
// 2. Span
|
||||
var values = series.Values.ToArray();
|
||||
var spanOutput = new double[values.Length];
|
||||
MeanDev.Batch(values.AsSpan(), spanOutput.AsSpan(), period);
|
||||
double spanResult = spanOutput[^1];
|
||||
|
||||
// 3. Streaming
|
||||
var streaming = new MeanDev(period);
|
||||
foreach (var tv in series)
|
||||
{
|
||||
streaming.Update(tv);
|
||||
}
|
||||
double streamingResult = streaming.Last.Value;
|
||||
|
||||
// 4. Eventing
|
||||
var pubSource = new TSeries();
|
||||
var eventing = new MeanDev(pubSource, period);
|
||||
foreach (var tv in series)
|
||||
{
|
||||
pubSource.Add(tv);
|
||||
}
|
||||
double eventingResult = eventing.Last.Value;
|
||||
|
||||
Assert.Equal(expected, spanResult, precision: 9);
|
||||
Assert.Equal(expected, streamingResult, precision: 9);
|
||||
Assert.Equal(expected, eventingResult, precision: 9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchTSeries_MatchesIterativeUpdate()
|
||||
{
|
||||
const int period = 10;
|
||||
var gbm = new GBM(seed: 7);
|
||||
var series = new TSeries();
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
series.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
var batchSeries = MeanDev.Batch(series, period);
|
||||
|
||||
var streaming = new MeanDev(period);
|
||||
TSeries streamingSeries = streaming.Update(series);
|
||||
|
||||
for (int i = 0; i < series.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchSeries[i].Value, streamingSeries[i].Value, precision: 9);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// G) Span API Tests
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevSpanTests
|
||||
{
|
||||
[Fact]
|
||||
public void Span_LengthMismatch_ThrowsArgumentException()
|
||||
{
|
||||
var src = new double[10];
|
||||
var dst = new double[9];
|
||||
var ex = Assert.Throws<ArgumentException>(() => MeanDev.Batch(src.AsSpan(), dst.AsSpan(), 5));
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Span_PeriodZero_ThrowsArgumentException()
|
||||
{
|
||||
var src = new double[10];
|
||||
var dst = new double[10];
|
||||
var ex = Assert.Throws<ArgumentException>(() => MeanDev.Batch(src.AsSpan(), dst.AsSpan(), 0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Span_EmptyInput_NoThrow()
|
||||
{
|
||||
var src = Array.Empty<double>();
|
||||
var dst = Array.Empty<double>();
|
||||
MeanDev.Batch(src.AsSpan(), dst.AsSpan(), 5);
|
||||
Assert.True(dst.Length == 0); // no throw; destination remains empty
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Span_MatchesTSeriesResult()
|
||||
{
|
||||
const int period = 7;
|
||||
var gbm = new GBM(seed: 99);
|
||||
var series = new TSeries();
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
series.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
var batchSeries = MeanDev.Batch(series, period);
|
||||
var values = series.Values.ToArray();
|
||||
var output = new double[values.Length];
|
||||
MeanDev.Batch(values.AsSpan(), output.AsSpan(), period);
|
||||
|
||||
for (int i = 0; i < series.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchSeries[i].Value, output[i], precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Span_HandlesNaN()
|
||||
{
|
||||
var src = new double[] { 1, 2, double.NaN, 4, 5, 6, 7 };
|
||||
var dst = new double[src.Length];
|
||||
MeanDev.Batch(src.AsSpan(), dst.AsSpan(), 3);
|
||||
Assert.True(dst.All(double.IsFinite));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Span_LargeInput_NoStackOverflow()
|
||||
{
|
||||
const int size = 10_000;
|
||||
var src = new double[size];
|
||||
var dst = new double[size];
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
src[i] = i;
|
||||
}
|
||||
MeanDev.Batch(src.AsSpan(), dst.AsSpan(), 20);
|
||||
Assert.True(double.IsFinite(dst[^1]));
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// H) Chainability
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class MeanDevChainabilityTests
|
||||
{
|
||||
[Fact]
|
||||
public void Pub_FiresOnUpdate()
|
||||
{
|
||||
var md = new MeanDev(5);
|
||||
int fired = 0;
|
||||
md.Pub += (object? _, in TValueEventArgs _) => fired++;
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, i + 1.0));
|
||||
}
|
||||
|
||||
Assert.Equal(10, fired);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EventBasedChaining_Works()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var md = new MeanDev(source, 5);
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.UtcNow.AddMinutes(i), (i + 1) * 10.0));
|
||||
}
|
||||
|
||||
Assert.True(md.IsHot);
|
||||
Assert.True(double.IsFinite(md.Last.Value));
|
||||
Assert.True(md.Last.Value >= 0.0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,239 @@
|
||||
using Tulip;
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// MeanDev cross-validation. ExcelAVEDEV formula and numpy mean(abs(x-mean(x)))
|
||||
/// are the reference implementations — both exact matches at default tolerance.
|
||||
/// Also cross-validated against Tulip <c>md</c> (Mean Deviation) — exact formula match.
|
||||
/// </summary>
|
||||
public class MeanDevValidationTests
|
||||
{
|
||||
// ─────────────────────────────────────────────────────────────
|
||||
// Reference implementation: pure-C# replication of the formula
|
||||
// ─────────────────────────────────────────────────────────────
|
||||
private static double ReferenceMeanDev(double[] window)
|
||||
{
|
||||
int n = window.Length;
|
||||
if (n == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
double mean = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
mean += window[i];
|
||||
}
|
||||
|
||||
mean /= n;
|
||||
double devSum = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
devSum += Math.Abs(window[i] - mean);
|
||||
}
|
||||
|
||||
return devSum / n;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_Matches_Reference_KnownData()
|
||||
{
|
||||
// window = {2, 4, 4, 4, 5, 5, 7, 9}: mean=5, MD=1.5
|
||||
double[] data = { 2, 4, 4, 4, 5, 5, 7, 9 };
|
||||
var md = new MeanDev(data.Length);
|
||||
foreach (double v in data)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, v));
|
||||
}
|
||||
double expected = ReferenceMeanDev(data);
|
||||
Assert.Equal(expected, md.Last.Value, precision: 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_Batch_Matches_Reference_GBM()
|
||||
{
|
||||
const int period = 14;
|
||||
var gbm = new GBM(seed: 12345);
|
||||
var closes = new List<double>();
|
||||
var series = new TSeries();
|
||||
for (int i = 0; i < 300; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
closes.Add(bar.Close);
|
||||
series.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
var result = MeanDev.Batch(series, period);
|
||||
|
||||
// Verify every bar against reference
|
||||
for (int i = period - 1; i < closes.Count; i++)
|
||||
{
|
||||
double[] window = closes.Skip(i - period + 1).Take(period).ToArray();
|
||||
double expected = ReferenceMeanDev(window);
|
||||
Assert.Equal(expected, result[i].Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_Streaming_Matches_Reference_GBM()
|
||||
{
|
||||
const int period = 20;
|
||||
var gbm = new GBM(seed: 54321);
|
||||
var closes = new List<double>();
|
||||
var md = new MeanDev(period);
|
||||
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
closes.Add(bar.Close);
|
||||
md.Update(new TValue(bar.Time, bar.Close));
|
||||
|
||||
if (i >= period - 1)
|
||||
{
|
||||
double[] window = closes.Skip(i - period + 1).Take(period).ToArray();
|
||||
double expected = ReferenceMeanDev(window);
|
||||
Assert.Equal(expected, md.Last.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_Span_Matches_Reference_GBM()
|
||||
{
|
||||
const int period = 10;
|
||||
var gbm = new GBM(seed: 999);
|
||||
var closes = new List<double>();
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
closes.Add(gbm.Next().Close);
|
||||
}
|
||||
|
||||
var src = closes.ToArray();
|
||||
var dst = new double[src.Length];
|
||||
MeanDev.Batch(src.AsSpan(), dst.AsSpan(), period);
|
||||
|
||||
for (int i = period - 1; i < closes.Count; i++)
|
||||
{
|
||||
double[] window = closes.Skip(i - period + 1).Take(period).ToArray();
|
||||
double expected = ReferenceMeanDev(window);
|
||||
Assert.Equal(expected, dst[i], precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_Period1_AlwaysZero()
|
||||
{
|
||||
// Single element: MD=0 regardless of value
|
||||
var md = new MeanDev(1);
|
||||
var gbm = new GBM(seed: 77);
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
md.Update(new TValue(bar.Time, bar.Close));
|
||||
Assert.Equal(0.0, md.Last.Value, precision: 10);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_SlidingWindow_CorrectlyDropsOldest()
|
||||
{
|
||||
// Period=3, feed 5 values, verify last window
|
||||
const int period = 3;
|
||||
double[] data = { 1, 2, 3, 4, 5 };
|
||||
var md = new MeanDev(period);
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
md.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
}
|
||||
// Last window = {3, 4, 5}: mean=4, MD=(1+0+1)/3 = 2/3
|
||||
double expected = ReferenceMeanDev(new double[] { 3, 4, 5 });
|
||||
Assert.Equal(expected, md.Last.Value, precision: 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_Relationship_To_StdDev()
|
||||
{
|
||||
// For any dataset, MD <= StdDev (population)
|
||||
const int period = 20;
|
||||
var gbm = new GBM(seed: 333);
|
||||
var series = new TSeries();
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
series.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
var mdResult = MeanDev.Batch(series, period);
|
||||
var sdResult = StdDev.Batch(series, period);
|
||||
|
||||
for (int i = period - 1; i < series.Count; i++)
|
||||
{
|
||||
Assert.True(mdResult[i].Value <= sdResult[i].Value + 1e-10,
|
||||
$"MD ({mdResult[i].Value}) > StdDev ({sdResult[i].Value}) at bar {i}");
|
||||
}
|
||||
}
|
||||
|
||||
// ── Tulip Cross-Validation ────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Validates MeanDev against Tulip <c>md</c> (Mean Deviation).
|
||||
/// Tulip formula: mean(|x - mean(x)|) over a rolling window — exact match.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void MeanDev_Matches_Tulip_Batch()
|
||||
{
|
||||
const int period = 14;
|
||||
var gbm = new GBM(seed: 42001);
|
||||
var series = new TSeries();
|
||||
var closeData = new List<double>();
|
||||
for (int i = 0; i < 500; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
series.Add(new TValue(bar.Time, bar.Close));
|
||||
closeData.Add(bar.Close);
|
||||
}
|
||||
|
||||
var qResult = MeanDev.Batch(series, period);
|
||||
|
||||
var tulipIndicator = Tulip.Indicators.md;
|
||||
double[] data = closeData.ToArray();
|
||||
double[][] inputs = { data };
|
||||
double[] options = { period };
|
||||
int lookback = tulipIndicator.Start(options);
|
||||
double[][] outputs = { new double[data.Length - lookback] };
|
||||
tulipIndicator.Run(inputs, options, outputs);
|
||||
double[] tResult = outputs[0];
|
||||
|
||||
ValidationHelper.VerifyData(qResult, tResult, lookback, tolerance: 1e-9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanDev_Matches_Tulip_Streaming()
|
||||
{
|
||||
const int period = 20;
|
||||
var gbm = new GBM(seed: 42002);
|
||||
var closeData = new List<double>();
|
||||
var md = new MeanDev(period);
|
||||
var qResults = new List<double>();
|
||||
|
||||
for (int i = 0; i < 500; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
closeData.Add(bar.Close);
|
||||
qResults.Add(md.Update(new TValue(bar.Time, bar.Close)).Value);
|
||||
}
|
||||
|
||||
var tulipIndicator = Tulip.Indicators.md;
|
||||
double[] data = closeData.ToArray();
|
||||
double[][] inputs = { data };
|
||||
double[] options = { period };
|
||||
int lookback = tulipIndicator.Start(options);
|
||||
double[][] outputs = { new double[data.Length - lookback] };
|
||||
tulipIndicator.Run(inputs, options, outputs);
|
||||
double[] tResult = outputs[0];
|
||||
|
||||
ValidationHelper.VerifyData(qResults, tResult, lookback, tolerance: 1e-9);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user