feat: add DMH (Ehlers Directional Movement with Hann) indicator

lib/dynamics/dmh/tests/Dmh.Quantower.Tests.cs

@@ -0,0 +1,138 @@
+using TradingPlatform.BusinessLayer;
+using QuanTAlib;
+
+namespace QuanTAlib.Tests;
+
+public class DmhIndicatorTests
+{
+    [Fact]
+    public void DmhIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new DmhIndicator();
+
+        Assert.Equal(14, indicator.Period);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("DMH - Ehlers Directional Movement with Hann", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void DmhIndicator_MinHistoryDepths_IsZero()
+    {
+        var indicator = new DmhIndicator { Period = 20 };
+
+        Assert.Equal(0, DmhIndicator.MinHistoryDepths);
+        IWatchlistIndicator watchlistIndicator = indicator;
+        Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void DmhIndicator_ShortName_IncludesPeriod()
+    {
+        var indicator = new DmhIndicator { Period = 20 };
+        indicator.Initialize();
+
+        Assert.Contains("DMH", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("20", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DmhIndicator_Name_ContainsEhlers()
+    {
+        var indicator = new DmhIndicator();
+        Assert.Contains("Ehlers", indicator.Name, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DmhIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new DmhIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Dmh.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DmhIndicator_Initialize_CreatesInternalDmh()
+    {
+        var indicator = new DmhIndicator { Period = 14 };
+
+        indicator.Initialize();
+
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void DmhIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new DmhIndicator { Period = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+        }
+
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void DmhIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new DmhIndicator { Period = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+        }
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(10), 110, 120, 100, 115);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void DmhIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new DmhIndicator { Period = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+        }
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void DmhIndicator_Parameters_CanBeChanged()
+    {
+        var indicator = new DmhIndicator { Period = 14 };
+        Assert.Equal(14, indicator.Period);
+
+        indicator.Period = 20;
+
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(0, DmhIndicator.MinHistoryDepths);
+    }
+}

lib/dynamics/dmh/tests/Dmh.Tests.cs

@@ -0,0 +1,454 @@
+
+namespace QuanTAlib;
+
+public class DmhTests
+{
+    [Fact]
+    public void Constructor_InvalidParameters_ThrowsException()
+    {
+        var ex1 = Assert.Throws<ArgumentOutOfRangeException>(() => new Dmh(0));
+        Assert.Contains("period", ex1.Message, StringComparison.OrdinalIgnoreCase);
+
+        var ex2 = Assert.Throws<ArgumentOutOfRangeException>(() => new Dmh(-1));
+        Assert.Contains("period", ex2.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Constructor_ValidPeriod_NoThrow()
+    {
+        var dmh = new Dmh(1);
+        Assert.Equal("Dmh(1)", dmh.Name);
+
+        var dmh14 = new Dmh(14);
+        Assert.Equal("Dmh(14)", dmh14.Name);
+        Assert.Equal(15, dmh14.WarmupPeriod);
+    }
+
+    [Fact]
+    public void BasicCalculation_DoesNotCrash()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(dmh.Last.Value));
+    }
+
+    [Fact]
+    public void IsHot_BecomesTrue_AfterWarmup()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < dmh.WarmupPeriod - 1; i++)
+        {
+            dmh.Update(bars[i]);
+            Assert.False(dmh.IsHot, $"Should not be hot at bar {i}");
+        }
+
+        dmh.Update(bars[dmh.WarmupPeriod - 1]);
+        Assert.True(dmh.IsHot, "Should be hot after warmup");
+    }
+
+    [Fact]
+    public void IsNew_Consistency()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < 99; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        dmh.Update(bars[99], true);
+
+        var modifiedBar = new TBar(bars[99].Time, bars[99].Open, bars[99].High + 1.0, bars[99].Low - 1.0, bars[99].Close, bars[99].Volume);
+        var val2 = dmh.Update(modifiedBar, false);
+
+        var dmh2 = new Dmh(14);
+        for (int i = 0; i < 99; i++)
+        {
+            dmh2.Update(bars[i]);
+        }
+        var val3 = dmh2.Update(modifiedBar, true);
+
+        Assert.Equal(val3.Value, val2.Value, 1e-9);
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreToOriginalState()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < 50; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        var originalValue = dmh.Last;
+
+        for (int m = 0; m < 5; m++)
+        {
+            var modified = new TBar(bars[49].Time, bars[49].Open, bars[49].High + m, bars[49].Low - m, bars[49].Close, bars[49].Volume);
+            dmh.Update(modified, isNew: false);
+        }
+
+        var restored = dmh.Update(bars[49], isNew: false);
+        Assert.Equal(originalValue.Value, restored.Value, 9);
+    }
+
+    [Fact]
+    public void Reset_Works()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        dmh.Reset();
+        Assert.Equal(0, dmh.Last.Value);
+        Assert.False(dmh.IsHot);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(dmh.Last.Value));
+        Assert.True(dmh.IsHot);
+    }
+
+    [Fact]
+    public void NaN_Input_UsesLastValidValue()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < 30; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        var nanBar = new TBar(DateTime.UtcNow, double.NaN, double.NaN, double.NaN, double.NaN, 100);
+        var result = dmh.Update(nanBar);
+
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Infinity_Input_UsesLastValidValue()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < 30; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        var infBar = new TBar(DateTime.UtcNow, double.PositiveInfinity, double.PositiveInfinity, 0, 100, 100);
+        var result = dmh.Update(infBar);
+
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void AllModes_ProduceSameResult()
+    {
+        var gbm = new GBM(seed: 123);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // 1. Batch Mode
+        var batchResult = Dmh.Batch(bars, 14);
+        double expected = batchResult.Last.Value;
+
+        // 2. Streaming Mode
+        var streamDmh = new Dmh(14);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamDmh.Update(bars[i]);
+        }
+
+        double streamResult = streamDmh.Last.Value;
+
+        Assert.Equal(expected, streamResult, 9);
+    }
+
+    [Fact]
+    public void TBarSeries_Update_Matches_Streaming()
+    {
+        var dmh = new Dmh(14);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var streamingResults = new List<double>();
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamingResults.Add(dmh.Update(bars[i]).Value);
+        }
+
+        var dmh2 = new Dmh(14);
+        var seriesResults = dmh2.Update(bars);
+
+        Assert.Equal(streamingResults.Count, seriesResults.Count);
+        for (int i = 0; i < seriesResults.Count; i++)
+        {
+            Assert.Equal(streamingResults[i], seriesResults.Values[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void FirstBar_Handling()
+    {
+        var dmh = new Dmh(14);
+        var bar = new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000);
+
+        var result = dmh.Update(bar);
+
+        Assert.Equal(0, result.Value);
+    }
+
+    [Fact]
+    public void StaticBatch_Matches_Streaming()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var dmh = new Dmh(14);
+        var streamingResults = new List<double>();
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamingResults.Add(dmh.Update(bars[i]).Value);
+        }
+
+        var staticResults = Dmh.Batch(bars, 14);
+
+        Assert.Equal(streamingResults.Count, staticResults.Count);
+        for (int i = 0; i < streamingResults.Count; i++)
+        {
+            Assert.Equal(streamingResults[i], staticResults.Values[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Chainability_Works()
+    {
+        var dmh = new Dmh(14);
+        var sma = new Sma(dmh, 10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(sma.Last.Value));
+    }
+
+    [Fact]
+    public void Uptrend_Produces_Positive_Values()
+    {
+        var dmh = new Dmh(14);
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+        double price = 100;
+
+        for (int i = 0; i < 50; i++)
+        {
+            bars.Add(time, price, price + 2, price - 1, price + 1, 1000);
+            time = time.AddMinutes(1);
+            price += 1.0;
+        }
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.True(dmh.Last.Value > 0, $"DMH should be positive in uptrend, got {dmh.Last.Value}");
+    }
+
+    [Fact]
+    public void Downtrend_Produces_Negative_Values()
+    {
+        var dmh = new Dmh(14);
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+        double price = 200;
+
+        for (int i = 0; i < 50; i++)
+        {
+            bars.Add(time, price, price + 1, price - 2, price - 1, 1000);
+            time = time.AddMinutes(1);
+            price -= 1.0;
+        }
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.True(dmh.Last.Value < 0, $"DMH should be negative in downtrend, got {dmh.Last.Value}");
+    }
+
+    [Fact]
+    public void SpanBatch_LengthMismatch_Throws()
+    {
+        var high = new double[10];
+        var low = new double[5];
+        var dest = new double[10];
+
+        Assert.Throws<ArgumentException>(() => Dmh.Batch(high, low, 14, dest));
+    }
+
+    [Fact]
+    public void SpanBatch_InvalidPeriod_Throws()
+    {
+        var high = new double[10];
+        var low = new double[10];
+        var dest = new double[10];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Dmh.Batch(high, low, 0, dest));
+    }
+
+    [Fact]
+    public void DifferentPeriods_ProduceDifferentResults()
+    {
+        var gbm = new GBM(seed: 42);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var dmh5 = new Dmh(5);
+        var dmh20 = new Dmh(20);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh5.Update(bars[i]);
+            dmh20.Update(bars[i]);
+        }
+
+        Assert.NotEqual(dmh5.Last.Value, dmh20.Last.Value);
+    }
+
+    [Fact]
+    public void EventPub_Fires()
+    {
+        var dmh = new Dmh(14);
+        int eventCount = 0;
+        dmh.Pub += (object? _, in TValueEventArgs _e) => eventCount++;
+
+        var gbm = new GBM();
+        var bars = gbm.Fetch(10, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.Equal(10, eventCount);
+    }
+
+    [Fact]
+    public void PrimePeriod_EqualsWarmupPeriod()
+    {
+        var dmh = new Dmh(14);
+        Assert.Equal(15, dmh.WarmupPeriod);
+
+        var dmh7 = new Dmh(7);
+        Assert.Equal(8, dmh7.WarmupPeriod);
+    }
+
+    [Fact]
+    public void Prime_Initializes_State()
+    {
+        var gbm = new GBM(seed: 42);
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var dmh1 = new Dmh(14);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh1.Update(bars[i]);
+        }
+
+        var dmh2 = new Dmh(14);
+        dmh2.Prime(bars);
+
+        Assert.Equal(dmh1.Last.Value, dmh2.Last.Value, 1e-9);
+        Assert.Equal(dmh1.IsHot, dmh2.IsHot);
+    }
+
+    [Fact]
+    public void Calculate_Returns_Results_And_Indicator()
+    {
+        var gbm = new GBM(seed: 42);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var (results, indicator) = Dmh.Calculate(bars, 14);
+
+        Assert.Equal(bars.Count, results.Count);
+        Assert.True(indicator.IsHot);
+        Assert.True(double.IsFinite(results.Last.Value));
+    }
+
+    [Fact]
+    public void ConstantPrice_Produces_Zero()
+    {
+        var dmh = new Dmh(14);
+        var time = DateTime.UtcNow;
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = new TBar(time, 100, 100, 100, 100, 1000);
+            dmh.Update(bar);
+            time = time.AddMinutes(1);
+        }
+
+        Assert.Equal(0.0, dmh.Last.Value, 1e-12);
+    }
+
+    [Fact]
+    public void Period1_Works()
+    {
+        var dmh = new Dmh(1);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(20, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(dmh.Last.Value));
+    }
+
+    [Fact]
+    public void LargePeriod_Works()
+    {
+        var dmh = new Dmh(200);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(dmh.Last.Value));
+    }
+}

lib/dynamics/dmh/tests/Dmh.Validation.Tests.cs

@@ -0,0 +1,200 @@
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public class DmhValidationTests
+{
+    private readonly ITestOutputHelper _output;
+
+    public DmhValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    [Fact]
+    public void Validate_Consistency_UpdateVsSeries()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var dmh = new Dmh(14);
+        var streamResult = new TSeries();
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamResult.Add(dmh.Update(bars[i]));
+        }
+
+        var dmh2 = new Dmh(14);
+        var seriesResult = dmh2.Update(bars);
+
+        Assert.Equal(streamResult.Count, seriesResult.Count);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            Assert.Equal(streamResult[i].Value, seriesResult[i].Value, ValidationHelper.DefaultTolerance);
+        }
+        _output.WriteLine("DMH Update vs Series validated successfully");
+    }
+
+    [Fact]
+    public void Validate_SpanBatch_Matches_Streaming()
+    {
+        var gbm = new GBM(seed: 99);
+        var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var dmh = new Dmh(14);
+        var streamResults = new double[bars.Count];
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamResults[i] = dmh.Update(bars[i]).Value;
+        }
+
+        var destination = new double[bars.Count];
+        Dmh.Batch(bars.High.Values, bars.Low.Values, 14, destination);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            Assert.Equal(streamResults[i], destination[i], ValidationHelper.DefaultTolerance);
+        }
+        _output.WriteLine("DMH Span batch vs Streaming validated successfully");
+    }
+
+    [Fact]
+    public void Validate_Trend_Direction()
+    {
+        // Synthetic uptrend
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+        double price = 100;
+        for (int i = 0; i < 100; i++)
+        {
+            bars.Add(time, price, price + 2, price - 1, price + 1, 1000);
+            time = time.AddMinutes(1);
+            price += 1.0;
+        }
+
+        var dmh = new Dmh(14);
+        var result = dmh.Update(bars);
+
+        for (int i = 80; i < 100; i++)
+        {
+            Assert.True(result[i].Value > 0, $"DMH should be positive in uptrend at index {i}, got {result[i].Value}");
+        }
+
+        // Synthetic downtrend
+        bars = new TBarSeries();
+        time = DateTime.UtcNow;
+        price = 200;
+        for (int i = 0; i < 100; i++)
+        {
+            bars.Add(time, price, price + 1, price - 2, price - 1, 1000);
+            time = time.AddMinutes(1);
+            price -= 1.0;
+        }
+
+        dmh = new Dmh(14);
+        result = dmh.Update(bars);
+
+        for (int i = 80; i < 100; i++)
+        {
+            Assert.True(result[i].Value < 0, $"DMH should be negative in downtrend at index {i}, got {result[i].Value}");
+        }
+
+        _output.WriteLine("DMH trend direction validated successfully");
+    }
+
+    [Fact]
+    public void Validate_ConstantPrice_ZeroOutput()
+    {
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+        for (int i = 0; i < 100; i++)
+        {
+            bars.Add(time, 100, 100, 100, 100, 1000);
+            time = time.AddMinutes(1);
+        }
+
+        var dmh = new Dmh(14);
+        var result = dmh.Update(bars);
+
+        for (int i = 0; i < 100; i++)
+        {
+            Assert.Equal(0.0, result[i].Value, 1e-12);
+        }
+        _output.WriteLine("DMH constant price → zero validated successfully");
+    }
+
+    [Fact]
+    public void Validate_DifferentPeriods()
+    {
+        var gbm = new GBM(seed: 42);
+        var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        foreach (int period in new[] { 5, 10, 14, 20, 50 })
+        {
+            var dmh = new Dmh(period);
+            for (int i = 0; i < bars.Count; i++)
+            {
+                var val = dmh.Update(bars[i]);
+                Assert.True(double.IsFinite(val.Value), $"DMH period={period}, bar={i}: non-finite value {val.Value}");
+            }
+        }
+        _output.WriteLine("DMH different periods validated successfully");
+    }
+
+    [Fact]
+    public void Validate_BarCorrection_Consistency()
+    {
+        var gbm = new GBM(seed: 77);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var dmh = new Dmh(14);
+        for (int i = 0; i < 100; i++)
+        {
+            dmh.Update(bars[i]);
+        }
+
+        var valueBeforeCorrection = dmh.Last.Value;
+
+        // Apply multiple corrections
+        for (int c = 0; c < 10; c++)
+        {
+            var modified = new TBar(bars[99].Time, bars[99].Open + c, bars[99].High + c, bars[99].Low - c, bars[99].Close + c, bars[99].Volume);
+            dmh.Update(modified, isNew: false);
+        }
+
+        // Restore original bar
+        var restored = dmh.Update(bars[99], isNew: false);
+        Assert.Equal(valueBeforeCorrection, restored.Value, 1e-9);
+        _output.WriteLine("DMH bar correction consistency validated successfully");
+    }
+
+    [Fact]
+    public void Validate_Subset_Stability()
+    {
+        var gbm = new GBM(seed: 55);
+        var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var dmhFull = new Dmh(14);
+        for (int i = 0; i < 500; i++)
+        {
+            dmhFull.Update(bars[i]);
+        }
+
+        var dmhSubset = new Dmh(14);
+        for (int i = 0; i < 300; i++)
+        {
+            dmhSubset.Update(bars[i]);
+        }
+
+        // Values at bar 299 should match
+        var dmhRef = new Dmh(14);
+        double val299 = 0;
+        for (int i = 0; i < 300; i++)
+        {
+            val299 = dmhRef.Update(bars[i]).Value;
+        }
+
+        Assert.Equal(val299, dmhSubset.Last.Value, 1e-9);
+        _output.WriteLine("DMH subset stability validated successfully");
+    }
+}