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

lib/oscillators/imi/tests/Imi.Quantower.Tests.cs

@@ -0,0 +1,144 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class ImiIndicatorTests
+{
+    [Fact]
+    public void ImiIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new ImiIndicator();
+
+        Assert.Equal(14, indicator.Period);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("Intraday Momentum Index", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void ImiIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new ImiIndicator { Period = 20 };
+
+        Assert.Equal(0, ImiIndicator.MinHistoryDepths);
+        IWatchlistIndicator watchlistIndicator = indicator;
+        Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ImiIndicator_ShortName_IncludesParameters()
+    {
+        var indicator = new ImiIndicator { Period = 20 };
+        indicator.Initialize();
+
+        Assert.Contains("IMI", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("20", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ImiIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new ImiIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Imi.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ImiIndicator_Initialize_CreatesInternalImi()
+    {
+        var indicator = new ImiIndicator { Period = 14 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist (single IMI line)
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void ImiIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new ImiIndicator { Period = 5 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        // Need enough bars for Period
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+
+            // Process update for each bar to simulate history loading
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Line series should have a value
+        double imi = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(imi));
+        Assert.InRange(imi, 0.0, 100.0);
+    }
+
+    [Fact]
+    public void ImiIndicator_AllUpBars_Returns100()
+    {
+        var indicator = new ImiIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 3; i++)
+        {
+            // Up bars: close > open
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 115, 99, 110);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // All up bars should result in 100
+        Assert.Equal(100.0, indicator.LinesSeries[0].GetValue(0), 0.0001);
+    }
+
+    [Fact]
+    public void ImiIndicator_AllDownBars_Returns0()
+    {
+        var indicator = new ImiIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 3; i++)
+        {
+            // Down bars: close < open
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 110, 115, 99, 100);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // All down bars should result in 0
+        Assert.Equal(0.0, indicator.LinesSeries[0].GetValue(0), 0.0001);
+    }
+
+    [Fact]
+    public void ImiIndicator_MixedBars_Returns50()
+    {
+        var indicator = new ImiIndicator { Period = 2 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Up bar: gain = 10
+        indicator.HistoricalData.AddBar(now, 100, 115, 99, 110);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Down bar: loss = 10
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 110, 115, 99, 100);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Equal gains and losses should result in 50
+        Assert.Equal(50.0, indicator.LinesSeries[0].GetValue(0), 0.0001);
+    }
+}

lib/oscillators/imi/tests/Imi.Tests.cs

@@ -0,0 +1,486 @@
+using System;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class ImiTests
+{
+    private const double Precision = 1e-10;
+
+    #region Constructor Tests
+
+    [Fact]
+    public void Constructor_DefaultPeriod_Is14()
+    {
+        var imi = new Imi();
+        Assert.Equal(14, imi.Period);
+    }
+
+    [Fact]
+    public void Constructor_CustomPeriod_IsSet()
+    {
+        var imi = new Imi(20);
+        Assert.Equal(20, imi.Period);
+    }
+
+    [Fact]
+    public void Constructor_Period1_IsValid()
+    {
+        var imi = new Imi(1);
+        Assert.Equal(1, imi.Period);
+    }
+
+    [Fact]
+    public void Constructor_ZeroPeriod_Throws()
+    {
+        Assert.Throws<ArgumentException>(() => new Imi(0));
+    }
+
+    [Fact]
+    public void Constructor_NegativePeriod_Throws()
+    {
+        Assert.Throws<ArgumentException>(() => new Imi(-1));
+    }
+
+    [Fact]
+    public void Name_ReflectsPeriod()
+    {
+        var imi = new Imi(10);
+        Assert.Equal("IMI(10)", imi.Name);
+    }
+
+    [Fact]
+    public void WarmupPeriod_EqualsToPeriod()
+    {
+        var imi = new Imi(14);
+        Assert.Equal(14, imi.WarmupPeriod);
+    }
+
+    #endregion
+
+    #region IsHot Tests
+
+    [Fact]
+    public void IsHot_BeforeWarmup_ReturnsFalse()
+    {
+        var imi = new Imi(5);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 4; i++)
+        {
+            imi.Update(new TBar(baseTime + i * 60000, 100, 105, 95, 102, 1000));
+        }
+
+        Assert.False(imi.IsHot);
+    }
+
+    [Fact]
+    public void IsHot_AfterWarmup_ReturnsTrue()
+    {
+        var imi = new Imi(5);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 5; i++)
+        {
+            imi.Update(new TBar(baseTime + i * 60000, 100, 105, 95, 102, 1000));
+        }
+
+        Assert.True(imi.IsHot);
+    }
+
+    #endregion
+
+    #region Basic Calculation Tests
+
+    [Fact]
+    public void Update_AllUpBars_Returns100()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // All bars have Close > Open (bullish candlesticks)
+        imi.Update(new TBar(baseTime, 100, 110, 99, 108, 1000));      // +8
+        imi.Update(new TBar(baseTime + 60000, 105, 112, 104, 111, 1000)); // +6
+        imi.Update(new TBar(baseTime + 120000, 108, 115, 107, 114, 1000)); // +6
+
+        Assert.Equal(100.0, imi.Last.Value, Precision);
+    }
+
+    [Fact]
+    public void Update_AllDownBars_Returns0()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // All bars have Close < Open (bearish candlesticks)
+        imi.Update(new TBar(baseTime, 108, 110, 99, 100, 1000));      // -8
+        imi.Update(new TBar(baseTime + 60000, 111, 112, 104, 105, 1000)); // -6
+        imi.Update(new TBar(baseTime + 120000, 114, 115, 107, 108, 1000)); // -6
+
+        Assert.Equal(0.0, imi.Last.Value, Precision);
+    }
+
+    [Fact]
+    public void Update_MixedBars_CorrectCalculation()
+    {
+        var imi = new Imi(4);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Up bar: gain = 5, loss = 0
+        imi.Update(new TBar(baseTime, 100, 110, 99, 105, 1000));
+
+        // Down bar: gain = 0, loss = 3
+        imi.Update(new TBar(baseTime + 60000, 105, 106, 100, 102, 1000));
+
+        // Up bar: gain = 4, loss = 0
+        imi.Update(new TBar(baseTime + 120000, 102, 108, 101, 106, 1000));
+
+        // Down bar: gain = 0, loss = 2
+        imi.Update(new TBar(baseTime + 180000, 106, 107, 103, 104, 1000));
+
+        // Gains = 5 + 4 = 9, Losses = 3 + 2 = 5
+        // IMI = 100 * 9 / (9 + 5) = 100 * 9 / 14 = 64.285714...
+        double expected = 100.0 * 9.0 / 14.0;
+        Assert.Equal(expected, imi.Last.Value, Precision);
+    }
+
+    [Fact]
+    public void Update_AllDoji_Returns50()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // All bars have Close == Open (doji candlesticks)
+        imi.Update(new TBar(baseTime, 100, 105, 95, 100, 1000));
+        imi.Update(new TBar(baseTime + 60000, 100, 108, 92, 100, 1000));
+        imi.Update(new TBar(baseTime + 120000, 100, 103, 97, 100, 1000));
+
+        // Sum of gains = 0, Sum of losses = 0, total = 0, returns 50 (neutral)
+        Assert.Equal(50.0, imi.Last.Value, Precision);
+    }
+
+    [Fact]
+    public void Update_EqualGainsAndLosses_Returns50()
+    {
+        var imi = new Imi(2);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Up bar: gain = 5
+        imi.Update(new TBar(baseTime, 100, 110, 99, 105, 1000));
+
+        // Down bar: loss = 5
+        imi.Update(new TBar(baseTime + 60000, 105, 106, 99, 100, 1000));
+
+        // Gains = 5, Losses = 5, IMI = 50
+        Assert.Equal(50.0, imi.Last.Value, Precision);
+    }
+
+    #endregion
+
+    #region Rolling Window Tests
+
+    [Fact]
+    public void Update_RollingWindow_DropsOldValues()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Fill with up bars
+        imi.Update(new TBar(baseTime, 100, 110, 99, 110, 1000));       // +10
+        imi.Update(new TBar(baseTime + 60000, 100, 110, 99, 110, 1000)); // +10
+        imi.Update(new TBar(baseTime + 120000, 100, 110, 99, 110, 1000)); // +10
+        Assert.Equal(100.0, imi.Last.Value, Precision);
+
+        // Add a down bar - oldest up bar should drop off
+        imi.Update(new TBar(baseTime + 180000, 110, 111, 99, 100, 1000)); // -10
+
+        // Now: gains = 10 + 10 = 20, losses = 10
+        // IMI = 100 * 20 / 30 = 66.666...
+        double expected = 100.0 * 20.0 / 30.0;
+        Assert.Equal(expected, imi.Last.Value, Precision);
+    }
+
+    #endregion
+
+    #region Bar Correction Tests
+
+    [Fact]
+    public void Update_BarCorrection_RestoresPreviousState()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Fill initial data
+        imi.Update(new TBar(baseTime, 100, 105, 95, 103, 1000));
+        imi.Update(new TBar(baseTime + 60000, 100, 105, 95, 104, 1000));
+        imi.Update(new TBar(baseTime + 120000, 100, 105, 95, 105, 1000));
+
+        // Add new bar (up)
+        imi.Update(new TBar(baseTime + 180000, 100, 107, 99, 106, 1000), isNew: true);
+        double valueAfterNew = imi.Last.Value;
+
+        // Correct the bar (now down)
+        imi.Update(new TBar(baseTime + 180000, 106, 107, 93, 94, 1000), isNew: false);
+        double valueAfterCorrection = imi.Last.Value;
+
+        // Values should differ based on the correction
+        Assert.NotEqual(valueAfterNew, valueAfterCorrection);
+    }
+
+    [Fact]
+    public void Update_MultipleCorrections_ProduceConsistentResults()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Fill buffer
+        for (int i = 0; i < 3; i++)
+        {
+            imi.Update(new TBar(baseTime + i * 60000, 100, 105, 95, 102, 1000));
+        }
+
+        // New bar
+        imi.Update(new TBar(baseTime + 3 * 60000, 100, 110, 99, 108, 1000), isNew: true);
+        double firstValue = imi.Last.Value;
+
+        // Correction 1
+        imi.Update(new TBar(baseTime + 3 * 60000, 100, 115, 99, 92, 1000), isNew: false);
+
+        // Correction 2 - same as first new bar
+        imi.Update(new TBar(baseTime + 3 * 60000, 100, 110, 99, 108, 1000), isNew: false);
+        double secondValue = imi.Last.Value;
+
+        Assert.Equal(firstValue, secondValue, Precision);
+    }
+
+    #endregion
+
+    #region NaN/Infinity Handling Tests
+
+    [Fact]
+    public void Update_NaNOpen_KeepsPreviousValue()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        imi.Update(new TBar(baseTime, 100, 105, 95, 103, 1000));
+        double validValue = imi.Last.Value;
+
+        imi.Update(new TBar(baseTime + 60000, double.NaN, 110, 99, 108, 1000));
+
+        Assert.Equal(validValue, imi.Last.Value);
+    }
+
+    [Fact]
+    public void Update_NaNClose_KeepsPreviousValue()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        imi.Update(new TBar(baseTime, 100, 105, 95, 103, 1000));
+        double validValue = imi.Last.Value;
+
+        imi.Update(new TBar(baseTime + 60000, 105, 110, 99, double.NaN, 1000));
+
+        Assert.Equal(validValue, imi.Last.Value);
+    }
+
+    [Fact]
+    public void Update_InfinityValues_KeepsPreviousValue()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        imi.Update(new TBar(baseTime, 100, 105, 95, 103, 1000));
+        double validValue = imi.Last.Value;
+
+        imi.Update(new TBar(baseTime + 60000, double.PositiveInfinity, 110, 99, 108, 1000));
+
+        Assert.Equal(validValue, imi.Last.Value);
+    }
+
+    #endregion
+
+    #region Reset Tests
+
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 5; i++)
+        {
+            imi.Update(new TBar(baseTime + i * 60000, 100, 110, 99, 108, 1000));
+        }
+
+        Assert.True(imi.IsHot);
+
+        imi.Reset();
+
+        Assert.False(imi.IsHot);
+        Assert.Equal(0, imi.Last.Value);
+    }
+
+    [Fact]
+    public void Reset_AllowsFreshStart()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // All up bars
+        for (int i = 0; i < 3; i++)
+        {
+            imi.Update(new TBar(baseTime + i * 60000, 100, 110, 99, 108, 1000));
+        }
+        Assert.Equal(100.0, imi.Last.Value, Precision);
+
+        imi.Reset();
+
+        // All down bars
+        for (int i = 0; i < 3; i++)
+        {
+            imi.Update(new TBar(baseTime + i * 60000, 108, 110, 99, 100, 1000));
+        }
+        Assert.Equal(0.0, imi.Last.Value, Precision);
+    }
+
+    #endregion
+
+    #region Prime Tests
+
+    [Fact]
+    public void Prime_FillsBuffer()
+    {
+        var imi = new Imi(5);
+        var source = new TBarSeries();
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 10; i++)
+        {
+            source.Add(new TBar(baseTime + i * 60000, 100, 110, 99, 108, 1000));
+        }
+
+        imi.Prime(source);
+
+        Assert.True(imi.IsHot);
+        Assert.Equal(100.0, imi.Last.Value, Precision);
+    }
+
+    #endregion
+
+    #region Batch Tests
+
+    [Fact]
+    public void Batch_ReturnsSeriesOfCorrectLength()
+    {
+        var source = new TBarSeries();
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 20; i++)
+        {
+            source.Add(new TBar(baseTime + i * 60000, 100 + i, 110 + i, 90 + i, 105 + i, 1000));
+        }
+
+        var result = Imi.Batch(source);
+
+        Assert.Equal(20, result.Count);
+    }
+
+    [Fact]
+    public void Batch_EmptySource_ReturnsEmpty()
+    {
+        var source = new TBarSeries();
+        var result = Imi.Batch(source);
+
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void Batch_CustomPeriod_AppliesCorrectly()
+    {
+        var source = new TBarSeries();
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 20; i++)
+        {
+            source.Add(new TBar(baseTime + i * 60000, 100, 110, 99, 108, 1000));
+        }
+
+        var result = Imi.Batch(source, 5);
+
+        Assert.Equal(20, result.Count);
+        Assert.Equal(100.0, result[^1].Value, Precision);
+    }
+
+    [Fact]
+    public void Calculate_ReturnsBothResultsAndIndicator()
+    {
+        var source = new TBarSeries();
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 20; i++)
+        {
+            source.Add(new TBar(baseTime + i * 60000, 100, 110, 99, 108, 1000));
+        }
+
+        var (results, indicator) = Imi.Calculate(source, 10);
+
+        Assert.Equal(20, results.Count);
+        Assert.True(indicator.IsHot);
+        Assert.Equal(10, indicator.Period);
+    }
+
+    #endregion
+
+    #region Event Publishing Tests
+
+    [Fact]
+    public void Update_PublishesEvent()
+    {
+        var imi = new Imi(3);
+        int eventCount = 0;
+        imi.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
+
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+        imi.Update(new TBar(baseTime, 100, 110, 99, 105, 1000));
+
+        Assert.Equal(1, eventCount);
+    }
+
+    [Fact]
+    public void Update_EventContainsCorrectValue()
+    {
+        var imi = new Imi(3);
+        TValue? receivedValue = null;
+        imi.Pub += (object? sender, in TValueEventArgs args) => receivedValue = args.Value;
+
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+        imi.Update(new TBar(baseTime, 100, 110, 99, 110, 1000));
+
+        Assert.NotNull(receivedValue);
+        Assert.Equal(imi.Last.Value, receivedValue.Value.Value);
+    }
+
+    #endregion
+
+    #region GBM Random Data Test
+
+    [Fact]
+    public void Update_GbmData_ReturnsValueInRange()
+    {
+        var imi = new Imi(14);
+        var gbm = new GBM(seed: 42);
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            imi.Update(bars[i]);
+
+            // IMI should always be in [0, 100]
+            Assert.InRange(imi.Last.Value, 0.0, 100.0);
+        }
+    }
+
+    #endregion
+}

lib/oscillators/imi/tests/Imi.Validation.Tests.cs

@@ -0,0 +1,332 @@
+using System;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+/// <summary>
+/// Validation tests for IMI (Intraday Momentum Index) implementation.
+/// These tests validate the calculation against the published formula by Tushar Chande:
+/// IMI = 100 × Sum(Gains) / (Sum(Gains) + Sum(Losses))
+/// where Gain = Close - Open if Close > Open, else 0
+/// and Loss = Open - Close if Close < Open, else 0
+/// </summary>
+public sealed class ImiValidationTests : IDisposable
+{
+    private readonly ITestOutputHelper _output;
+
+    public ImiValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    public void Dispose()
+    {
+        // Cleanup if needed
+    }
+
+    #region Manual Calculation Verification
+
+    [Fact]
+    public void ManualCalculation_SimpleUpBars()
+    {
+        // Given 3 up bars with known gains
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Bar 1: Open=100, Close=105 → Gain=5
+        imi.Update(new TBar(baseTime, 100, 108, 98, 105, 1000));
+
+        // Bar 2: Open=105, Close=108 → Gain=3
+        imi.Update(new TBar(baseTime + 60000, 105, 110, 104, 108, 1000));
+
+        // Bar 3: Open=108, Close=110 → Gain=2
+        imi.Update(new TBar(baseTime + 120000, 108, 112, 107, 110, 1000));
+
+        // Total gains = 5 + 3 + 2 = 10
+        // Total losses = 0
+        // IMI = 100 × 10 / (10 + 0) = 100
+
+        Assert.Equal(100.0, imi.Last.Value, 1e-10);
+
+        _output.WriteLine($"Gains: 5 + 3 + 2 = 10");
+        _output.WriteLine($"Losses: 0");
+        _output.WriteLine($"IMI = 100 × 10 / 10 = {imi.Last.Value}");
+    }
+
+    [Fact]
+    public void ManualCalculation_SimpleDownBars()
+    {
+        // Given 3 down bars with known losses
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Bar 1: Open=105, Close=100 → Loss=5
+        imi.Update(new TBar(baseTime, 105, 108, 98, 100, 1000));
+
+        // Bar 2: Open=100, Close=97 → Loss=3
+        imi.Update(new TBar(baseTime + 60000, 100, 102, 95, 97, 1000));
+
+        // Bar 3: Open=97, Close=95 → Loss=2
+        imi.Update(new TBar(baseTime + 120000, 97, 99, 93, 95, 1000));
+
+        // Total gains = 0
+        // Total losses = 5 + 3 + 2 = 10
+        // IMI = 100 × 0 / (0 + 10) = 0
+
+        Assert.Equal(0.0, imi.Last.Value, 1e-10);
+
+        _output.WriteLine($"Gains: 0");
+        _output.WriteLine($"Losses: 5 + 3 + 2 = 10");
+        _output.WriteLine($"IMI = 100 × 0 / 10 = {imi.Last.Value}");
+    }
+
+    [Fact]
+    public void ManualCalculation_MixedBars()
+    {
+        // Given a mix of up and down bars
+        var imi = new Imi(5);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Bar 1: Open=100, Close=106 → Gain=6
+        imi.Update(new TBar(baseTime, 100, 108, 98, 106, 1000));
+
+        // Bar 2: Open=106, Close=102 → Loss=4
+        imi.Update(new TBar(baseTime + 60000, 106, 108, 100, 102, 1000));
+
+        // Bar 3: Open=102, Close=105 → Gain=3
+        imi.Update(new TBar(baseTime + 120000, 102, 107, 101, 105, 1000));
+
+        // Bar 4: Open=105, Close=105 → Doji (Gain=0, Loss=0)
+        imi.Update(new TBar(baseTime + 180000, 105, 108, 102, 105, 1000));
+
+        // Bar 5: Open=105, Close=103 → Loss=2
+        imi.Update(new TBar(baseTime + 240000, 105, 107, 101, 103, 1000));
+
+        // Total gains = 6 + 3 = 9
+        // Total losses = 4 + 2 = 6
+        // IMI = 100 × 9 / (9 + 6) = 100 × 9 / 15 = 60
+
+        double expected = 100.0 * 9.0 / 15.0;
+        Assert.Equal(expected, imi.Last.Value, 1e-10);
+
+        _output.WriteLine($"Gains: 6 + 0 + 3 + 0 + 0 = 9");
+        _output.WriteLine($"Losses: 0 + 4 + 0 + 0 + 2 = 6");
+        _output.WriteLine($"IMI = 100 × 9 / 15 = {expected}");
+        _output.WriteLine($"Actual: {imi.Last.Value}");
+    }
+
+    #endregion
+
+    #region Rolling Window Validation
+
+    [Fact]
+    public void RollingWindow_DropsOldestValue()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Fill with 3 up bars (gains: 5, 5, 5)
+        imi.Update(new TBar(baseTime, 100, 108, 98, 105, 1000));         // +5
+        imi.Update(new TBar(baseTime + 60000, 100, 108, 98, 105, 1000)); // +5
+        imi.Update(new TBar(baseTime + 120000, 100, 108, 98, 105, 1000)); // +5
+
+        Assert.Equal(100.0, imi.Last.Value, 1e-10);
+
+        // Add a down bar (loss: 5) - oldest gain (5) drops off
+        imi.Update(new TBar(baseTime + 180000, 105, 108, 98, 100, 1000)); // -5
+
+        // Now: gains = 5 + 5 = 10, losses = 5
+        // IMI = 100 × 10 / 15 = 66.666...
+        double expected = 100.0 * 10.0 / 15.0;
+        Assert.Equal(expected, imi.Last.Value, 1e-10);
+
+        _output.WriteLine($"After 4th bar:");
+        _output.WriteLine($"  Window: [+5, +5, -5]");
+        _output.WriteLine($"  Gains: 5 + 5 = 10");
+        _output.WriteLine($"  Losses: 5");
+        _output.WriteLine($"  IMI = {expected}");
+    }
+
+    #endregion
+
+    #region Edge Case Validation
+
+    [Fact]
+    public void EdgeCase_AllDojiBars_Returns50()
+    {
+        // When all bars are doji (Open == Close), IMI should be 50 (neutral)
+        var imi = new Imi(5);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        for (int i = 0; i < 5; i++)
+        {
+            // Doji: Open == Close
+            imi.Update(new TBar(baseTime + i * 60000, 100, 105, 95, 100, 1000));
+        }
+
+        Assert.Equal(50.0, imi.Last.Value, 1e-10);
+        _output.WriteLine("All doji bars (O==C) → IMI = 50 (neutral)");
+    }
+
+    [Fact]
+    public void EdgeCase_VerySmallMovements()
+    {
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Very small gains
+        imi.Update(new TBar(baseTime, 100.0, 100.1, 99.9, 100.0001, 1000));
+        imi.Update(new TBar(baseTime + 60000, 100.0, 100.1, 99.9, 100.0002, 1000));
+        imi.Update(new TBar(baseTime + 120000, 100.0, 100.1, 99.9, 100.0003, 1000));
+
+        // All are tiny up bars, should still be 100
+        Assert.Equal(100.0, imi.Last.Value, 1e-10);
+        _output.WriteLine($"Very small gains still → IMI = {imi.Last.Value}");
+    }
+
+    [Fact]
+    public void EdgeCase_Period1()
+    {
+        // With period 1, each bar is its own calculation
+        var imi = new Imi(1);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Up bar
+        imi.Update(new TBar(baseTime, 100, 110, 95, 108, 1000));
+        Assert.Equal(100.0, imi.Last.Value, 1e-10);
+
+        // Down bar
+        imi.Update(new TBar(baseTime + 60000, 108, 110, 95, 100, 1000));
+        Assert.Equal(0.0, imi.Last.Value, 1e-10);
+
+        // Doji
+        imi.Update(new TBar(baseTime + 120000, 100, 105, 95, 100, 1000));
+        Assert.Equal(50.0, imi.Last.Value, 1e-10);
+
+        _output.WriteLine("Period=1: Each bar → immediate IMI response");
+    }
+
+    #endregion
+
+    #region Investopedia Example Validation
+
+    [Fact]
+    public void InvestopediaFormula_MatchesDefinition()
+    {
+        // Validate against Investopedia formula:
+        // IMI = (Sum of Up Closes / (Sum of Up Closes + Sum of Down Closes)) × 100
+        // Where Up Close = Close - Open when Close > Open
+
+        var imi = new Imi(4);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Day 1: Close > Open (Up day: +3)
+        imi.Update(new TBar(baseTime, 50, 54, 49, 53, 1000));
+
+        // Day 2: Close < Open (Down day: -2)
+        imi.Update(new TBar(baseTime + 86400000, 53, 54, 50, 51, 1000));
+
+        // Day 3: Close > Open (Up day: +4)
+        imi.Update(new TBar(baseTime + 172800000, 51, 56, 50, 55, 1000));
+
+        // Day 4: Close > Open (Up day: +1)
+        imi.Update(new TBar(baseTime + 259200000, 55, 57, 54, 56, 1000));
+
+        // Sum of Up Closes = 3 + 4 + 1 = 8
+        // Sum of Down Closes = 2
+        // IMI = 100 × 8 / (8 + 2) = 80
+
+        double expected = 100.0 * 8.0 / 10.0;
+        Assert.Equal(expected, imi.Last.Value, 1e-10);
+
+        _output.WriteLine("Investopedia formula validation:");
+        _output.WriteLine($"  Up gains: 3 + 4 + 1 = 8");
+        _output.WriteLine($"  Down losses: 2");
+        _output.WriteLine($"  IMI = 100 × 8 / 10 = {expected}");
+    }
+
+    #endregion
+
+    #region Comparison with RSI Concept
+
+    [Fact]
+    public void ImiVsRsiConcept_UsesIntradayNotInterday()
+    {
+        // IMI differs from RSI in that it uses Open-to-Close (intraday)
+        // rather than Close-to-Close (interday)
+
+        var imi = new Imi(3);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Bar 1: Open=100, Close=105 (up bar, +5)
+        // Bar 2: Open=110, Close=108 (down bar, -2) 
+        //        Note: This is up from prev close (105→108) but down intraday!
+        // Bar 3: Open=105, Close=110 (up bar, +5)
+
+        imi.Update(new TBar(baseTime, 100, 108, 98, 105, 1000));
+        imi.Update(new TBar(baseTime + 60000, 110, 112, 106, 108, 1000)); // Intraday down
+        imi.Update(new TBar(baseTime + 120000, 105, 112, 104, 110, 1000));
+
+        // Gains = 5 + 5 = 10
+        // Losses = 2
+        // IMI = 100 × 10 / 12 = 83.333...
+
+        double expected = 100.0 * 10.0 / 12.0;
+        Assert.Equal(expected, imi.Last.Value, 1e-10);
+
+        _output.WriteLine("IMI uses Open-to-Close (intraday), not Close-to-Close (interday)");
+        _output.WriteLine($"Bar 2: Opens at 110, closes at 108 → DOWN day for IMI");
+        _output.WriteLine($"IMI = {imi.Last.Value:F4}");
+    }
+
+    #endregion
+
+    #region Overbought/Oversold Levels
+
+    [Fact]
+    public void OverboughtLevel_Above70()
+    {
+        var imi = new Imi(5);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Create scenario with IMI > 70 (overbought)
+        // Need gains > 2.33 × losses for IMI > 70
+        // 4 up bars (+5 each), 1 down bar (-3)
+        // Gains = 20, Losses = 3
+        // IMI = 100 × 20/23 = 86.96
+
+        imi.Update(new TBar(baseTime, 100, 108, 98, 105, 1000));         // +5
+        imi.Update(new TBar(baseTime + 60000, 100, 108, 98, 105, 1000)); // +5
+        imi.Update(new TBar(baseTime + 120000, 100, 108, 98, 105, 1000)); // +5
+        imi.Update(new TBar(baseTime + 180000, 100, 108, 98, 105, 1000)); // +5
+        imi.Update(new TBar(baseTime + 240000, 100, 102, 95, 97, 1000)); // -3
+
+        Assert.True(imi.Last.Value > 70);
+        _output.WriteLine($"Overbought (>70): IMI = {imi.Last.Value:F2}");
+    }
+
+    [Fact]
+    public void OversoldLevel_Below30()
+    {
+        var imi = new Imi(5);
+        long baseTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+        // Create scenario with IMI < 30 (oversold)
+        // Need losses > 2.33 × gains for IMI < 30
+        // 4 down bars (-5 each), 1 up bar (+3)
+        // Gains = 3, Losses = 20
+        // IMI = 100 × 3/23 = 13.04
+
+        imi.Update(new TBar(baseTime, 105, 108, 98, 100, 1000));         // -5
+        imi.Update(new TBar(baseTime + 60000, 105, 108, 98, 100, 1000)); // -5
+        imi.Update(new TBar(baseTime + 120000, 105, 108, 98, 100, 1000)); // -5
+        imi.Update(new TBar(baseTime + 180000, 105, 108, 98, 100, 1000)); // -5
+        imi.Update(new TBar(baseTime + 240000, 100, 108, 98, 103, 1000)); // +3
+
+        Assert.True(imi.Last.Value < 30);
+        _output.WriteLine($"Oversold (<30): IMI = {imi.Last.Value:F2}");
+    }
+
+    #endregion
+}