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/volume/vo/tests/Vo.Quantower.Tests.cs

@@ -0,0 +1,313 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class VoIndicatorTests
+{
+    [Fact]
+    public void VoIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new VoIndicator();
+
+        Assert.Equal("VO - Volume Oscillator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+        Assert.Equal(5, indicator.ShortPeriod);
+        Assert.Equal(10, indicator.LongPeriod);
+        Assert.Equal(10, indicator.SignalPeriod);
+        Assert.Equal(10, indicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void VoIndicator_ShortName_ReflectsPeriods()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 7, SignalPeriod = 5 };
+        Assert.Equal("VO(3,7,5)", indicator.ShortName);
+    }
+
+    [Fact]
+    public void VoIndicator_MinHistoryDepths_EqualsLongPeriod()
+    {
+        var indicator = new VoIndicator { LongPeriod = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void VoIndicator_Periods_CanBeSet()
+    {
+        var indicator = new VoIndicator
+        {
+            ShortPeriod = 12,
+            LongPeriod = 26,
+            SignalPeriod = 9
+        };
+
+        Assert.Equal(12, indicator.ShortPeriod);
+        Assert.Equal(26, indicator.LongPeriod);
+        Assert.Equal(9, indicator.SignalPeriod);
+    }
+
+    [Fact]
+    public void VoIndicator_Initialize_CreatesInternalVo()
+    {
+        var indicator = new VoIndicator();
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist (VO + Signal)
+        Assert.Equal(2, indicator.LinesSeries.Count);
+    }
+
+    [Fact]
+    public void VoIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 5, LongPeriod = 10, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; i++)
+        {
+            double volume = 100000 + i * 1000;
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 105, volume);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        double signalVal = indicator.LinesSeries[1].GetValue(0);
+
+        Assert.True(double.IsFinite(voVal));
+        Assert.True(double.IsFinite(signalVal));
+    }
+
+    [Fact]
+    public void VoIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 5, LongPeriod = 10, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 105, 100000);
+        }
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Add new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(30), 105, 115, 100, 112, 80000);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+        Assert.Equal(2, indicator.LinesSeries[1].Count);
+    }
+
+    [Fact]
+    public void VoIndicator_ConstantVolume_ZeroOscillator()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // All bars with same volume
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, 50000);
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.Equal(0, voVal, 1);
+    }
+
+    [Fact]
+    public void VoIndicator_IncreasingVolume_PositiveOscillator()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Volume increases over time - short MA will exceed long MA
+        for (int i = 0; i < 20; i++)
+        {
+            double volume = 10000 + i * 5000; // Increasing volume
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(voVal > 0, $"VO should be positive when volume increasing: {voVal}");
+    }
+
+    [Fact]
+    public void VoIndicator_DecreasingVolume_NegativeOscillator()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Volume decreases over time - short MA will be below long MA
+        for (int i = 0; i < 20; i++)
+        {
+            double volume = 100000 - i * 4000; // Decreasing volume
+            volume = Math.Max(volume, 1000); // Keep positive
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(voVal < 0, $"VO should be negative when volume decreasing: {voVal}");
+    }
+
+    [Fact]
+    public void VoIndicator_SignalLine_SmoothsVo()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        var voValues = new List<double>();
+        var signalValues = new List<double>();
+
+        // Add oscillating volume
+        for (int i = 0; i < 30; i++)
+        {
+            double volume = 50000 + (i % 2 == 0 ? 20000 : -10000);
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+
+            if (i >= 10) // After warmup
+            {
+                voValues.Add(indicator.LinesSeries[0].GetValue(0));
+                signalValues.Add(indicator.LinesSeries[1].GetValue(0));
+            }
+        }
+
+        // Signal line should be smoother (smaller range)
+        double voRange = voValues.Max() - voValues.Min();
+        double signalRange = signalValues.Max() - signalValues.Min();
+
+        Assert.True(signalRange <= voRange, $"Signal should be smoother: VO range={voRange}, Signal range={signalRange}");
+    }
+
+    [Fact]
+    public void VoIndicator_DifferentPeriods_DifferentResults()
+    {
+        var shortPeriods = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        shortPeriods.Initialize();
+
+        var longPeriods = new VoIndicator { ShortPeriod = 10, LongPeriod = 20, SignalPeriod = 10 };
+        longPeriods.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Add same data to both
+        for (int i = 0; i < 50; i++)
+        {
+            double volume = 50000 + Math.Sin(i * 0.3) * 20000;
+            shortPeriods.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+            longPeriods.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            shortPeriods.ProcessUpdate(args);
+            longPeriods.ProcessUpdate(args);
+        }
+
+        double shortVal = shortPeriods.LinesSeries[0].GetValue(0);
+        double longVal = longPeriods.LinesSeries[0].GetValue(0);
+
+        // Different periods should produce different results
+        Assert.NotEqual(shortVal, longVal, 3);
+    }
+
+    [Fact]
+    public void VoIndicator_ReturnsPercentage()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 2, LongPeriod = 4, SignalPeriod = 2 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Start with baseline volume
+        for (int i = 0; i < 5; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, 10000);
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Add bar with significantly higher volume
+        indicator.HistoricalData.AddBar(now.AddMinutes(5), 100, 105, 95, 100, 20000);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+
+        // VO should be positive percentage (short MA > long MA)
+        Assert.True(voVal > 0, $"VO should be positive: {voVal}");
+        Assert.True(voVal <= 200, $"VO should be reasonable percentage: {voVal}"); // Not too extreme
+    }
+
+    [Fact]
+    public void VoIndicator_OscillatesAroundZero()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 5, LongPeriod = 10, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        bool hasPositive = false;
+        bool hasNegative = false;
+
+        // Oscillating volume pattern
+        for (int i = 0; i < 50; i++)
+        {
+            double volume = 50000 + Math.Sin(i * 0.5) * 30000;
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+
+            if (i > 15) // After warmup
+            {
+                double val = indicator.LinesSeries[0].GetValue(0);
+                if (val > 0.5)
+                {
+                    hasPositive = true;
+                }
+                if (val < -0.5)
+                {
+                    hasNegative = true;
+                }
+            }
+        }
+
+        Assert.True(hasPositive && hasNegative, "VO should oscillate around zero");
+    }
+}

lib/volume/vo/tests/Vo.Tests.cs

@@ -0,0 +1,602 @@
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class VoTests
+{
+    private const double Tolerance = 1e-10;
+    private readonly GBM _gbm;
+    private readonly TBarSeries _bars;
+
+    public VoTests()
+    {
+        _gbm = new GBM(seed: 42);
+        _bars = _gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+    }
+
+    #region Constructor Tests
+
+    [Fact]
+    public void Constructor_DefaultPeriods_SetsExpectedValues()
+    {
+        var vo = new Vo();
+        Assert.Equal("Vo(5,10,10)", vo.Name);
+        Assert.Equal(10, vo.WarmupPeriod);
+    }
+
+    [Fact]
+    public void Constructor_CustomPeriods_SetsExpectedValues()
+    {
+        var vo = new Vo(shortPeriod: 3, longPeriod: 7, signalPeriod: 5);
+        Assert.Equal("Vo(3,7,5)", vo.Name);
+        Assert.Equal(7, vo.WarmupPeriod);
+    }
+
+    [Fact]
+    public void Constructor_ShortPeriodLessThan1_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Vo(shortPeriod: 0));
+        Assert.Equal("shortPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_LongPeriodLessThan1_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Vo(shortPeriod: 2, longPeriod: 0));
+        Assert.Equal("longPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_ShortPeriodGreaterOrEqualLongPeriod_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Vo(shortPeriod: 10, longPeriod: 10));
+        Assert.Equal("shortPeriod", ex.ParamName);
+
+        ex = Assert.Throws<ArgumentException>(() => new Vo(shortPeriod: 15, longPeriod: 10));
+        Assert.Equal("shortPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_SignalPeriodLessThan1_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Vo(shortPeriod: 5, longPeriod: 10, signalPeriod: 0));
+        Assert.Equal("signalPeriod", ex.ParamName);
+    }
+
+    #endregion
+
+    #region Basic Calculation Tests
+
+    [Fact]
+    public void Update_ReturnsTValue()
+    {
+        var vo = new Vo();
+        var result = vo.Update(_bars[0]);
+        Assert.IsType<TValue>(result);
+    }
+
+    [Fact]
+    public void Update_AccessesLastAndSignal()
+    {
+        var vo = new Vo();
+        vo.Update(_bars[0]);
+        Assert.Equal(vo.Last.Value, vo.Update(_bars[0], isNew: false).Value);
+        _ = vo.Signal; // Access signal property
+    }
+
+    [Fact]
+    public void Update_SameVolumes_ReturnsZero()
+    {
+        var vo = new Vo(shortPeriod: 2, longPeriod: 4, signalPeriod: 2);
+        var now = DateTime.UtcNow;
+
+        // All same volumes should result in VO = 0
+        for (int i = 0; i < 10; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000);
+            vo.Update(bar, isNew: true);
+        }
+
+        Assert.Equal(0.0, vo.Last.Value, Tolerance);
+    }
+
+    [Fact]
+    public void Update_IncreasingVolumes_ReturnsPositive()
+    {
+        var vo = new Vo(shortPeriod: 2, longPeriod: 4, signalPeriod: 2);
+        var now = DateTime.UtcNow;
+
+        // Create a pattern where short MA > long MA at the end
+        // Volumes: 100, 100, 100, 100, 500, 1000
+        // At bar 5 (index 5): short SMA (2) = (500+1000)/2 = 750
+        //                     long SMA (4) = (100+100+500+1000)/4 = 425
+        // VO = ((750 - 425) / 425) * 100 = 76.47% (positive)
+        double[] volumes = [100, 100, 100, 100, 500, 1000];
+        for (int i = 0; i < volumes.Length; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, volumes[i]);
+            vo.Update(bar, isNew: true);
+        }
+
+        Assert.True(vo.Last.Value > 0, $"Expected positive VO but got {vo.Last.Value}");
+    }
+
+    [Fact]
+    public void Update_DecreasingVolumes_ReturnsNegative()
+    {
+        var vo = new Vo(shortPeriod: 2, longPeriod: 4, signalPeriod: 2);
+        var now = DateTime.UtcNow;
+
+        // Create a pattern where short MA < long MA at the end
+        // Volumes: 1000, 1000, 1000, 1000, 500, 100
+        // At bar 5 (index 5): short SMA (2) = (500+100)/2 = 300
+        //                     long SMA (4) = (1000+1000+500+100)/4 = 650
+        // VO = ((300 - 650) / 650) * 100 = -53.85% (negative)
+        double[] volumes = [1000, 1000, 1000, 1000, 500, 100];
+        for (int i = 0; i < volumes.Length; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, volumes[i]);
+            vo.Update(bar, isNew: true);
+        }
+
+        Assert.True(vo.Last.Value < 0, $"Expected negative VO but got {vo.Last.Value}");
+    }
+
+    #endregion
+
+    #region State Management Tests
+
+    [Fact]
+    public void IsNew_True_AdvancesState()
+    {
+        var vo = new Vo(shortPeriod: 2, longPeriod: 4, signalPeriod: 2);
+        var now = DateTime.UtcNow;
+
+        // Feed enough bars to get past warmup with varying volumes
+        // to ensure state advances (index changes)
+        double[] volumes = [100, 200, 300, 400, 500];
+        for (int i = 0; i < volumes.Length; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, volumes[i]);
+            vo.Update(bar, isNew: true);
+        }
+
+        var stateBeforeNewBar = vo.Last.Value;
+
+        // Add another bar with different volume
+        var newBar = new TBar(now.AddMinutes(5), 100, 100, 100, 100, 1000);
+        vo.Update(newBar, isNew: true);
+
+        // State should have advanced (different value due to new volume in moving averages)
+        Assert.NotEqual(stateBeforeNewBar, vo.Last.Value);
+    }
+
+    [Fact]
+    public void IsNew_False_UpdatesCurrentBar()
+    {
+        var vo = new Vo(shortPeriod: 2, longPeriod: 4, signalPeriod: 2);
+        var now = DateTime.UtcNow;
+
+        var bar1 = new TBar(now, 100, 100, 100, 100, 500);
+        vo.Update(bar1, isNew: true);
+
+        var bar2 = new TBar(now, 100, 100, 100, 100, 600);
+        vo.Update(bar2, isNew: false);
+
+        var bar3 = new TBar(now, 100, 100, 100, 100, 500);
+        var result = vo.Update(bar3, isNew: false);
+
+        Assert.Equal(vo.Update(bar1, isNew: false).Value, result.Value, Tolerance);
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreState()
+    {
+        var vo = new Vo(shortPeriod: 3, longPeriod: 6, signalPeriod: 3);
+        var now = DateTime.UtcNow;
+
+        // Add several bars
+        for (int i = 0; i < 10; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500 + i * 10);
+            vo.Update(bar, isNew: true);
+        }
+
+        var stateBeforeCorrections = vo.Last.Value;
+
+        // Apply multiple corrections
+        for (int j = 0; j < 5; j++)
+        {
+            var correctionBar = new TBar(now.AddMinutes(9), 100, 100, 100, 100, 700 + j * 10);
+            vo.Update(correctionBar, isNew: false);
+        }
+
+        // Restore original bar
+        var originalBar = new TBar(now.AddMinutes(9), 100, 100, 100, 100, 590);
+        var restored = vo.Update(originalBar, isNew: false);
+
+        Assert.Equal(stateBeforeCorrections, restored.Value, Tolerance);
+    }
+
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var vo = new Vo();
+
+        // Process some bars
+        for (int i = 0; i < 20; i++)
+        {
+            vo.Update(_bars[i], isNew: true);
+        }
+
+        Assert.True(vo.IsHot);
+
+        vo.Reset();
+
+        Assert.False(vo.IsHot);
+        Assert.Equal(default, vo.Last);
+    }
+
+    #endregion
+
+    #region Warmup Tests
+
+    [Fact]
+    public void IsHot_BeforeWarmup_ReturnsFalse()
+    {
+        var vo = new Vo(shortPeriod: 3, longPeriod: 10, signalPeriod: 5);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 9; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
+            vo.Update(bar, isNew: true);
+            Assert.False(vo.IsHot, $"Should not be hot at index {i}");
+        }
+    }
+
+    [Fact]
+    public void IsHot_AfterWarmup_ReturnsTrue()
+    {
+        var vo = new Vo(shortPeriod: 3, longPeriod: 10, signalPeriod: 5);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 10; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
+            vo.Update(bar, isNew: true);
+        }
+
+        Assert.True(vo.IsHot);
+    }
+
+    [Fact]
+    public void WarmupPeriod_EqualsLongPeriod()
+    {
+        var vo = new Vo(shortPeriod: 5, longPeriod: 15, signalPeriod: 10);
+        Assert.Equal(15, vo.WarmupPeriod);
+    }
+
+    #endregion
+
+    #region Robustness Tests
+
+    [Fact]
+    public void Update_NaN_UsesLastValidValue()
+    {
+        var vo = new Vo(shortPeriod: 2, longPeriod: 4, signalPeriod: 2);
+        var now = DateTime.UtcNow;
+
+        // Add valid bars
+        for (int i = 0; i < 5; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
+            vo.Update(bar, isNew: true);
+        }
+
+        // Add bar with NaN volume
+        var nanBar = new TBar(now.AddMinutes(5), 100, 100, 100, 100, double.NaN);
+        var result = vo.Update(nanBar, isNew: true);
+
+        Assert.True(double.IsFinite(result.Value), "Result should be finite after NaN input");
+    }
+
+    [Fact]
+    public void Update_Infinity_UsesLastValidValue()
+    {
+        var vo = new Vo(shortPeriod: 2, longPeriod: 4, signalPeriod: 2);
+        var now = DateTime.UtcNow;
+
+        // Add valid bars
+        for (int i = 0; i < 5; i++)
+        {
+            var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
+            vo.Update(bar, isNew: true);
+        }
+
+        // Add bar with Infinity volume
+        var infBar = new TBar(now.AddMinutes(5), 100, 100, 100, 100, double.PositiveInfinity);
+        var result = vo.Update(infBar, isNew: true);
+
+        Assert.True(double.IsFinite(result.Value), "Result should be finite after Infinity input");
+    }
+
+    [Fact]
+    public void BatchUpdate_WithNaN_Safe()
+    {
+        var vo = new Vo();
+        var bars = new TBarSeries();
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 20; i++)
+        {
+            double volume = i == 10 ? double.NaN : 500 + i;
+            bars.Add(new TBar(now.AddMinutes(i), 100, 100, 100, 100, volume));
+        }
+
+        var result = vo.Update(bars);
+
+        Assert.Equal(20, result.Count);
+        foreach (var val in result.Values)
+        {
+            Assert.True(double.IsFinite(val), "All values should be finite");
+        }
+    }
+
+    #endregion
+
+    #region Consistency Tests
+
+    [Fact]
+    public void BatchCalc_EqualsStreaming()
+    {
+        var vo = new Vo(shortPeriod: 5, longPeriod: 10, signalPeriod: 10);
+
+        // Streaming
+        var streamingResults = new List<double>();
+        for (int i = 0; i < _bars.Count; i++)
+        {
+            var result = vo.Update(_bars[i], isNew: true);
+            streamingResults.Add(result.Value);
+        }
+
+        // Batch
+        var batchResult = Vo.Batch(_bars, shortPeriod: 5, longPeriod: 10, signalPeriod: 10);
+
+        Assert.Equal(streamingResults.Count, batchResult.Count);
+        for (int i = 0; i < streamingResults.Count; i++)
+        {
+            Assert.Equal(streamingResults[i], batchResult.Values[i], Tolerance);
+        }
+    }
+
+    [Fact]
+    public void SpanCalc_EqualsStreaming()
+    {
+        var vo = new Vo(shortPeriod: 5, longPeriod: 10, signalPeriod: 10);
+
+        // Streaming
+        var streamingResults = new List<double>();
+        for (int i = 0; i < _bars.Count; i++)
+        {
+            var result = vo.Update(_bars[i], isNew: true);
+            streamingResults.Add(result.Value);
+        }
+
+        // Span - pass arrays directly (implicit span conversion)
+        var volume = _bars.Volume.Values.ToArray();
+        var output = new double[_bars.Count];
+        Vo.Batch(volume, output, shortPeriod: 5, longPeriod: 10);
+
+        for (int i = 0; i < streamingResults.Count; i++)
+        {
+            Assert.Equal(streamingResults[i], output[i], Tolerance);
+        }
+    }
+
+    [Fact]
+    public void BatchUpdate_EqualsStreaming()
+    {
+        var voStream = new Vo(shortPeriod: 5, longPeriod: 10, signalPeriod: 10);
+        var voBatch = new Vo(shortPeriod: 5, longPeriod: 10, signalPeriod: 10);
+
+        // Streaming
+        for (int i = 0; i < _bars.Count; i++)
+        {
+            voStream.Update(_bars[i], isNew: true);
+        }
+
+        // Batch
+        var batchResult = voBatch.Update(_bars);
+
+        Assert.Equal(voStream.Last.Value, batchResult.Values[^1], Tolerance);
+    }
+
+    #endregion
+
+    #region Span API Tests
+
+    [Fact]
+    public void Calculate_Span_ValidatesLengths()
+    {
+        var volume = new double[100];
+        var output = new double[50]; // Wrong length
+
+        ArgumentException? caught = null;
+        try
+        {
+            Vo.Batch(volume, output, shortPeriod: 5, longPeriod: 10);
+        }
+        catch (ArgumentException ex)
+        {
+            caught = ex;
+        }
+
+        Assert.NotNull(caught);
+        Assert.Equal("output", caught.ParamName);
+    }
+
+    [Fact]
+    public void Calculate_Span_ValidatesShortPeriod()
+    {
+        var volume = new double[100];
+        var output = new double[100];
+
+        ArgumentException? caught = null;
+        try
+        {
+            Vo.Batch(volume, output, shortPeriod: 0, longPeriod: 10);
+        }
+        catch (ArgumentException ex)
+        {
+            caught = ex;
+        }
+
+        Assert.NotNull(caught);
+        Assert.Equal("shortPeriod", caught.ParamName);
+    }
+
+    [Fact]
+    public void Calculate_Span_ValidatesLongPeriod()
+    {
+        var volume = new double[100];
+        var output = new double[100];
+
+        ArgumentException? caught = null;
+        try
+        {
+            Vo.Batch(volume, output, shortPeriod: 5, longPeriod: 0);
+        }
+        catch (ArgumentException ex)
+        {
+            caught = ex;
+        }
+
+        Assert.NotNull(caught);
+        Assert.Equal("longPeriod", caught.ParamName);
+    }
+
+    [Fact]
+    public void Calculate_Span_ValidatesShortLessThanLong()
+    {
+        var volume = new double[100];
+        var output = new double[100];
+
+        ArgumentException? caught = null;
+        try
+        {
+            Vo.Batch(volume, output, shortPeriod: 10, longPeriod: 5);
+        }
+        catch (ArgumentException ex)
+        {
+            caught = ex;
+        }
+
+        Assert.NotNull(caught);
+        Assert.Equal("shortPeriod", caught.ParamName);
+    }
+
+    [Fact]
+    public void Calculate_Span_HandlesEmpty()
+    {
+        double[] volumeArr = [];
+        double[] outputArr = [];
+
+        // Should not throw
+        Vo.Batch(volumeArr, outputArr, shortPeriod: 5, longPeriod: 10);
+
+        Assert.Empty(outputArr);
+    }
+
+    [Fact]
+    public void Calculate_Span_HandlesNaN()
+    {
+        var volume = new double[20];
+        var output = new double[20];
+
+        for (int i = 0; i < 20; i++)
+        {
+            volume[i] = i == 10 ? double.NaN : 500 + i;
+        }
+
+        Vo.Batch(volume, output, shortPeriod: 5, longPeriod: 10);
+
+        foreach (var val in output)
+        {
+            Assert.True(double.IsFinite(val), "All values should be finite");
+        }
+    }
+
+    [Fact]
+    public void Calculate_Span_LargeData_NoStackOverflow()
+    {
+        var volume = new double[10000];
+        var output = new double[10000];
+
+        for (int i = 0; i < 10000; i++)
+        {
+            volume[i] = 500 + (i % 100);
+        }
+
+        // Should not throw stack overflow
+        Vo.Batch(volume, output, shortPeriod: 50, longPeriod: 200);
+
+        Assert.True(double.IsFinite(output[^1]));
+    }
+
+    #endregion
+
+    #region Event Tests
+
+    [Fact]
+    public void Pub_FiresOnUpdate()
+    {
+        var vo = new Vo();
+        var eventFired = false;
+
+        vo.Pub += (object? sender, in TValueEventArgs args) => { eventFired = true; };
+        vo.Update(_bars[0]);
+
+        Assert.True(eventFired);
+    }
+
+    [Fact]
+    public void Pub_ChainingWorks()
+    {
+        var vo = new Vo();
+        var receivedValues = new List<double>();
+
+        vo.Pub += (object? sender, in TValueEventArgs args) => { receivedValues.Add(args.Value.Value); };
+
+        for (int i = 0; i < 20; i++)
+        {
+            vo.Update(_bars[i], isNew: true);
+        }
+
+        Assert.Equal(20, receivedValues.Count);
+    }
+
+    #endregion
+
+    #region TValue Input Tests
+
+    [Fact]
+    public void Update_TValue_PreservesLastValue()
+    {
+        var vo = new Vo();
+        var now = DateTime.UtcNow;
+
+        // First update with bar to set a value
+        var bar = new TBar(now, 100, 100, 100, 100, 500);
+        vo.Update(bar, isNew: true);
+        var lastValue = vo.Last.Value;
+
+        // TValue update should preserve last value (VO requires volume)
+        var tval = new TValue(now.AddMinutes(1), 200);
+        var result = vo.Update(tval, isNew: true);
+
+        Assert.Equal(lastValue, result.Value, Tolerance);
+    }
+
+    #endregion
+}

lib/volume/vo/tests/Vo.Validation.Tests.cs

@@ -0,0 +1,259 @@
+// Vo: Mathematical property validation tests
+// Volume Oscillator compares short and long SMAs of volume.
+// No standard external library equivalents with matching implementation.
+// Validation uses mathematical property testing.
+
+using Tulip;
+
+namespace QuanTAlib.Tests;
+
+using Xunit;
+
+public class VoValidationTests
+{
+    private const int DefaultShortPeriod = 5;
+    private const int DefaultLongPeriod = 10;
+    private const int DefaultSignalPeriod = 10;
+    private const int TestDataLength = 500;
+
+    [Fact]
+    public void Vo_Output_IsFiniteForGbmData()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(TestDataLength, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            var result = vo.Update(bars[i], isNew: true);
+            Assert.True(double.IsFinite(result.Value),
+                $"Vo output must be finite at bar {i}, got {result.Value}");
+        }
+    }
+
+    [Fact]
+    public void Vo_ConstantVolume_ZeroOscillator()
+    {
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        // Feed bars with identical volume
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                100, 101, 99, 100, 1000); // constant volume
+            vo.Update(bar, isNew: true);
+        }
+
+        // When volume is constant, short MA == long MA, VO = 0
+        Assert.Equal(0.0, vo.Last.Value, precision: 8);
+    }
+
+    [Fact]
+    public void Vo_IncreasingVolume_PositiveOscillator()
+    {
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        // Feed bars with steadily increasing volume
+        for (int i = 0; i < 50; i++)
+        {
+            double volume = 1000 + i * 100; // increasing
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                100, 101, 99, 100, volume);
+            vo.Update(bar, isNew: true);
+        }
+
+        // Short MA should be higher than long MA when volume is increasing
+        Assert.True(vo.Last.Value > 0,
+            $"VO should be positive with increasing volume, got {vo.Last.Value}");
+    }
+
+    [Fact]
+    public void Vo_DecreasingVolume_NegativeOscillator()
+    {
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        // Feed bars with steadily decreasing volume
+        for (int i = 0; i < 50; i++)
+        {
+            double volume = 10000 - i * 100; // decreasing
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                100, 101, 99, 100, volume);
+            vo.Update(bar, isNew: true);
+        }
+
+        // Short MA should be lower than long MA when volume is decreasing
+        Assert.True(vo.Last.Value < 0,
+            $"VO should be negative with decreasing volume, got {vo.Last.Value}");
+    }
+
+    [Fact]
+    public void Vo_Signal_IsFinite()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(TestDataLength, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            vo.Update(bars[i], isNew: true);
+            Assert.True(double.IsFinite(vo.Signal),
+                $"Signal must be finite at bar {i}, got {vo.Signal}");
+        }
+    }
+
+    [Fact]
+    public void Vo_ConstantVolume_SignalAlsoZero()
+    {
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                100, 101, 99, 100, 1000);
+            vo.Update(bar, isNew: true);
+        }
+
+        // Signal is SMA of VO values, all of which are zero
+        Assert.Equal(0.0, vo.Signal, precision: 8);
+    }
+
+    [Fact]
+    public void Vo_BatchAndStreaming_ProduceSameResults()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(TestDataLength, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Batch
+        var batchResults = Vo.Batch(bars, DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        // Streaming
+        var streamVo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+        var streamResults = new double[bars.Count];
+        for (int i = 0; i < bars.Count; i++)
+        {
+            var result = streamVo.Update(bars[i], isNew: true);
+            streamResults[i] = result.Value;
+        }
+
+        Assert.Equal(batchResults.Count, bars.Count);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            Assert.Equal(batchResults.Values[i], streamResults[i], precision: 8);
+        }
+    }
+
+    [Fact]
+    public void Vo_DifferentPeriods_ProduceDifferentResults()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var vo1 = new Vo(3, 7, 5);
+        var vo2 = new Vo(10, 30, 15);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            vo1.Update(bars[i], isNew: true);
+            vo2.Update(bars[i], isNew: true);
+        }
+
+        Assert.NotEqual(vo1.Last.Value, vo2.Last.Value);
+    }
+
+    [Fact]
+    public void Vo_BarCorrection_IsNewFalse_RestoresState()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        for (int i = 0; i < 30; i++)
+        {
+            vo.Update(bars[i], isNew: true);
+        }
+
+        vo.Update(bars[30], isNew: true);
+        double afterNew = vo.Last.Value;
+
+        vo.Update(bars[30], isNew: false);
+        double afterCorrection = vo.Last.Value;
+
+        Assert.Equal(afterNew, afterCorrection, precision: 10);
+    }
+
+    [Fact]
+    public void Vo_IsHot_AfterLongPeriod()
+    {
+        var vo = new Vo(DefaultShortPeriod, DefaultLongPeriod, DefaultSignalPeriod);
+
+        for (int i = 0; i < DefaultLongPeriod - 1; i++)
+        {
+            var bar = new TBar(DateTime.UtcNow.AddMinutes(i), 100, 101, 99, 100, 1000);
+            vo.Update(bar, isNew: true);
+            Assert.False(vo.IsHot, $"Should not be hot at bar {i}");
+        }
+
+        // Bar at index longPeriod-1 should make it hot (Index becomes longPeriod)
+        var finalBar = new TBar(DateTime.UtcNow.AddMinutes(DefaultLongPeriod), 100, 101, 99, 100, 1000);
+        vo.Update(finalBar, isNew: true);
+        Assert.True(vo.IsHot, "Should be hot after longPeriod bars");
+    }
+
+    // === Tulip Cross-Validation ===
+
+    /// <summary>
+    /// Structural validation against Tulip <c>vosc</c> (volume oscillator).
+    /// Algorithm variant: Tulip <c>vosc</c> takes one input (volume only) with two options
+    /// (short_period, long_period) and computes <c>(sma_short - sma_long) / sma_long × 100</c>.
+    /// QuanTAlib Vo also adds an optional signal EMA. With <c>signalPeriod=1</c> the signal
+    /// equals Vo itself, so raw Vo output is directly comparable to Tulip vosc.
+    /// </summary>
+    [Fact]
+    public void Vo_Matches_Tulip_Vosc_Batch()
+    {
+        const int shortPeriod = 5;
+        const int longPeriod = 10;
+        var bars = new GBM(sigma: 0.3, seed: 42).Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        double[] volumeData = new double[bars.Count];
+        for (int i = 0; i < bars.Count; i++) { volumeData[i] = bars[i].Volume; }
+
+        // QuanTAlib Vo batch
+        var qResult = Vo.Batch(bars, shortPeriod, longPeriod, signalPeriod: 1);
+
+        // Tulip vosc — volume only, no signal period
+        var tulipIndicator = Tulip.Indicators.vosc;
+        double[][] inputs = { volumeData };
+        double[] options = { shortPeriod, longPeriod };
+        int lookback = tulipIndicator.Start(options);
+        double[][] outputs = { new double[volumeData.Length - lookback] };
+        tulipIndicator.Run(inputs, options, outputs);
+        double[] tResult = outputs[0];
+
+        ValidationHelper.VerifyData(qResult, tResult, lookback);
+    }
+
+    [Fact]
+    public void Vo_Matches_Tulip_Vosc_Streaming()
+    {
+        const int shortPeriod = 5;
+        const int longPeriod = 10;
+        var bars = new GBM(sigma: 0.3, seed: 42).Fetch(300, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        double[] volumeData = new double[bars.Count];
+        for (int i = 0; i < bars.Count; i++) { volumeData[i] = bars[i].Volume; }
+
+        // QuanTAlib Vo streaming (signalPeriod=1 → signal equals Vo)
+        var vo = new Vo(shortPeriod, longPeriod, signalPeriod: 1);
+        var qResults = new List<double>();
+        foreach (var bar in bars) { qResults.Add(vo.Update(bar).Value); }
+
+        // Tulip vosc
+        var tulipIndicator = Tulip.Indicators.vosc;
+        double[][] inputs = { volumeData };
+        double[] options = { shortPeriod, longPeriod };
+        int lookback = tulipIndicator.Start(options);
+        double[][] outputs = { new double[volumeData.Length - lookback] };
+        tulipIndicator.Run(inputs, options, outputs);
+        double[] tResult = outputs[0];
+
+        ValidationHelper.VerifyData(qResults, tResult, lookback);
+    }
+}