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
2026-08-25 05:48:06 +00:00 · 2026-03-12 12:34:16 -07:00
parent 8937b0c0fa
commit 060649192f
1149 changed files with 1780 additions and 3316 deletions
@@ -0,0 +1,211 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class KvoIndicatorTests
+{
+    [Fact]
+    public void KvoIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new KvoIndicator();
+
+        Assert.Equal("KVO - Klinger Volume Oscillator", indicator.Name);
+        Assert.Equal(34, indicator.FastPeriod);
+        Assert.Equal(55, indicator.SlowPeriod);
+        Assert.Equal(13, indicator.SignalPeriod);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+        Assert.Equal(55, indicator.MinHistoryDepths); // SlowPeriod
+    }
+
+    [Fact]
+    public void KvoIndicator_ShortName_ReflectsPeriods()
+    {
+        var indicator = new KvoIndicator { FastPeriod = 20, SlowPeriod = 40, SignalPeriod = 10 };
+        Assert.Equal("KVO(20,40,10)", indicator.ShortName);
+    }
+
+    [Fact]
+    public void KvoIndicator_MinHistoryDepths_EqualsSlowPeriod()
+    {
+        var indicator = new KvoIndicator { SlowPeriod = 80 };
+
+        Assert.Equal(80, indicator.MinHistoryDepths);
+        Assert.Equal(80, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void KvoIndicator_Initialize_CreatesInternalKvo()
+    {
+        var indicator = new KvoIndicator();
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, two line series should exist (KVO and Signal)
+        Assert.Equal(2, indicator.LinesSeries.Count);
+    }
+
+    [Fact]
+    public void KvoIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new KvoIndicator();
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 60; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 1000 + (i * 100));
+
+            // Process update for each bar to simulate history loading
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // KVO series should have a value
+        double kvoVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(kvoVal));
+
+        // Signal series should have a value
+        double signalVal = indicator.LinesSeries[1].GetValue(0);
+        Assert.True(double.IsFinite(signalVal));
+    }
+
+    [Fact]
+    public void KvoIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new KvoIndicator();
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 60; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 1000 + (i * 100));
+        }
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Add new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(60), 160, 170, 150, 165, 7000);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+        Assert.Equal(2, indicator.LinesSeries[1].Count);
+    }
+
+    [Fact]
+    public void KvoIndicator_Value_IsFinite()
+    {
+        var indicator = new KvoIndicator();
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 80; i++)
+        {
+            // Create varying price patterns
+            double open = 100 + i;
+            double high = open + 10 + (i % 5);
+            double low = open - 5;
+            double close = (i % 2 == 0) ? high - 1 : low + 1;
+            double volume = 1000 + (i * 100);
+
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), open, high, low, close, volume);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double kvoVal = indicator.LinesSeries[0].GetValue(0);
+        double signalVal = indicator.LinesSeries[1].GetValue(0);
+        Assert.True(double.IsFinite(kvoVal), $"KVO value {kvoVal} should be finite");
+        Assert.True(double.IsFinite(signalVal), $"Signal value {signalVal} should be finite");
+    }
+
+    [Fact]
+    public void KvoIndicator_PositiveValue_OnUpwardMovement()
+    {
+        var indicator = new KvoIndicator { FastPeriod = 3, SlowPeriod = 5, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Add bars with increasing prices (uptrend with accumulation)
+        for (int i = 0; i < 15; i++)
+        {
+            double basePrice = 100 + (i * 3);
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 2, basePrice + 3, 1000000 + (i * 100000));
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double val = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(val > 0, $"KVO should be positive on sustained upward movement, got {val}");
+    }
+
+    [Fact]
+    public void KvoIndicator_NegativeValue_OnDownwardMovement()
+    {
+        var indicator = new KvoIndicator { FastPeriod = 3, SlowPeriod = 5, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Add bars with decreasing prices (downtrend with distribution)
+        for (int i = 0; i < 15; i++)
+        {
+            double basePrice = 200 - (i * 4);
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 2, basePrice - 5, basePrice - 3, 1000000 + (i * 100000));
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double val = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(val < 0, $"KVO should be negative on sustained downward movement, got {val}");
+    }
+
+    [Fact]
+    public void KvoIndicator_SignalLine_CalculatedCorrectly()
+    {
+        var indicator = new KvoIndicator { FastPeriod = 5, SlowPeriod = 10, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; i++)
+        {
+            double basePrice = 100 + i;
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 5, basePrice + 2, 50000 + (i * 1000));
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double kvoVal = indicator.LinesSeries[0].GetValue(0);
+        double signalVal = indicator.LinesSeries[1].GetValue(0);
+
+        Assert.True(double.IsFinite(kvoVal));
+        Assert.True(double.IsFinite(signalVal));
+        // Signal is an EMA of KVO, so they should be different in trending conditions
+    }
+
+    [Fact]
+    public void KvoIndicator_CustomPeriods_AffectsOutput()
+    {
+        var indicator1 = new KvoIndicator { FastPeriod = 10, SlowPeriod = 20, SignalPeriod = 5 };
+        var indicator2 = new KvoIndicator { FastPeriod = 20, SlowPeriod = 40, SignalPeriod = 10 };
+        indicator1.Initialize();
+        indicator2.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 50; i++)
+        {
+            double basePrice = 100 + i;
+            indicator1.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 5, basePrice + 2, 50000 + (i * 1000));
+            indicator2.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 5, basePrice + 2, 50000 + (i * 1000));
+            indicator1.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            indicator2.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double val1 = indicator1.LinesSeries[0].GetValue(0);
+        double val2 = indicator2.LinesSeries[0].GetValue(0);
+
+        // Different periods should produce different results
+        Assert.NotEqual(val1, val2);
+        Assert.True(double.IsFinite(val1));
+        Assert.True(double.IsFinite(val2));
+    }
+}
@@ -0,0 +1,512 @@
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class KvoTests
+{
+    private const int DefaultFastPeriod = 34;
+    private const int DefaultSlowPeriod = 55;
+    private const int DefaultSignalPeriod = 13;
+
+    [Fact]
+    public void Constructor_DefaultParameters_CreatesValidIndicator()
+    {
+        var kvo = new Kvo();
+        Assert.Equal($"Kvo({DefaultFastPeriod},{DefaultSlowPeriod},{DefaultSignalPeriod})", kvo.Name);
+        Assert.Equal(DefaultSlowPeriod, kvo.WarmupPeriod);
+        Assert.False(kvo.IsHot);
+    }
+
+    [Fact]
+    public void Constructor_CustomParameters_CreatesValidIndicator()
+    {
+        var kvo = new Kvo(fastPeriod: 20, slowPeriod: 40, signalPeriod: 10);
+        Assert.Equal("Kvo(20,40,10)", kvo.Name);
+        Assert.Equal(40, kvo.WarmupPeriod);
+    }
+
+    [Fact]
+    public void Constructor_InvalidFastPeriod_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Kvo(fastPeriod: 0));
+        Assert.Throws<ArgumentException>(() => new Kvo(fastPeriod: -1));
+    }
+
+    [Fact]
+    public void Constructor_InvalidSlowPeriod_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Kvo(slowPeriod: 0));
+        Assert.Throws<ArgumentException>(() => new Kvo(slowPeriod: -1));
+    }
+
+    [Fact]
+    public void Constructor_InvalidSignalPeriod_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Kvo(signalPeriod: 0));
+        Assert.Throws<ArgumentException>(() => new Kvo(signalPeriod: -1));
+    }
+
+    [Fact]
+    public void Constructor_FastNotLessThanSlow_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Kvo(fastPeriod: 55, slowPeriod: 55));
+        Assert.Throws<ArgumentException>(() => new Kvo(fastPeriod: 60, slowPeriod: 55));
+    }
+
+    [Fact]
+    public void Update_WithTBar_ReturnsValidValue()
+    {
+        var kvo = new Kvo();
+        var bar = new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000000);
+        var result = kvo.Update(bar);
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Update_WithTValue_ThrowsNotSupportedException()
+    {
+        var kvo = new Kvo();
+        var value = new TValue(DateTime.UtcNow, 100);
+        Assert.Throws<NotSupportedException>(() => kvo.Update(value));
+    }
+
+    [Fact]
+    public void Update_PriceIncrease_ReturnsFiniteValue()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        // Simulate uptrend with increasing prices and volume
+        for (int i = 0; i < 100; i++)
+        {
+            double basePrice = 100 + i * 2;
+            kvo.Update(new TBar(time.AddMinutes(i), basePrice, basePrice + 5, basePrice - 2, basePrice + 3, 1000000 + i * 100000));
+        }
+
+        // After warmup, KVO should have finite values
+        Assert.True(double.IsFinite(kvo.Last.Value), "KVO should return finite values");
+    }
+
+    [Fact]
+    public void Update_PriceDecrease_ReturnsFiniteValue()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        // Simulate downtrend with decreasing prices
+        for (int i = 0; i < 100; i++)
+        {
+            double basePrice = 500 - i * 3;
+            kvo.Update(new TBar(time.AddMinutes(i), basePrice, basePrice + 2, basePrice - 5, basePrice - 3, 1000000 + i * 100000));
+        }
+
+        // After warmup, KVO should have finite values
+        Assert.True(double.IsFinite(kvo.Last.Value), "KVO should return finite values");
+    }
+
+    [Fact]
+    public void Update_IsNewTrue_AdvancesState()
+    {
+        var kvo = new Kvo();
+        var bar1 = new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000000);
+        var result1 = kvo.Update(bar1, isNew: true);
+
+        var bar2 = new TBar(DateTime.UtcNow.AddMinutes(1), 105, 115, 95, 110, 1100000);
+        var result2 = kvo.Update(bar2, isNew: true);
+
+        Assert.NotEqual(result1.Time, result2.Time);
+    }
+
+    [Fact]
+    public void Update_IsNewFalse_UpdatesCurrentBar()
+    {
+        var kvo = new Kvo();
+        var time = DateTime.UtcNow;
+        var bar1 = new TBar(time, 100, 110, 90, 105, 1000000);
+        kvo.Update(bar1, isNew: true);
+
+        var bar2 = new TBar(time.AddMinutes(1), 105, 115, 95, 110, 1100000);
+        var result1 = kvo.Update(bar2, isNew: true);
+
+        // Update same bar with different values
+        var bar2Updated = new TBar(time.AddMinutes(1), 105, 120, 95, 118, 1500000);
+        var result2 = kvo.Update(bar2Updated, isNew: false);
+
+        Assert.Equal(result1.Time, result2.Time);
+        Assert.NotEqual(result1.Value, result2.Value);
+    }
+
+    [Fact]
+    public void Update_IterativeCorrections_RestoresState()
+    {
+        var kvo = new Kvo(fastPeriod: 5, slowPeriod: 10, signalPeriod: 5);
+        var time = DateTime.UtcNow;
+
+        // Build up state
+        for (int i = 0; i < 15; i++)
+        {
+            kvo.Update(new TBar(time.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 100000 + i * 10000), isNew: true);
+        }
+
+        // New bar
+        var originalBar = new TBar(time.AddMinutes(15), 120, 130, 110, 125, 250000);
+        var originalResult = kvo.Update(originalBar, isNew: true);
+
+        // Correction with different values
+        var correctionBar = new TBar(time.AddMinutes(15), 110, 150, 90, 140, 500000);
+        var correctedResult = kvo.Update(correctionBar, isNew: false);
+
+        Assert.NotEqual(originalResult.Value, correctedResult.Value);
+        Assert.True(double.IsFinite(correctedResult.Value));
+    }
+
+    [Fact]
+    public void Update_WarmupPeriod_IsHotBecomesTrueAfterWarmup()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        Assert.False(kvo.IsHot);
+
+        // Feed many bars until compensators decay below threshold (1e-10)
+        // With period 5, decay = 1 - 2/(5+1) = 0.667, needs ~50 bars for e^(-50*0.4) < 1e-10
+        for (int i = 0; i < 100; i++)
+        {
+            kvo.Update(new TBar(time.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 100000), isNew: true);
+        }
+
+        // After sufficient bars, compensators should decay and IsHot becomes true
+        Assert.True(kvo.IsHot);
+    }
+
+    [Fact]
+    public void Update_WithNaN_UsesLastValidValue()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        // Process some valid bars first
+        for (int i = 0; i < 10; i++)
+        {
+            kvo.Update(new TBar(time.AddMinutes(i), 100, 105, 95, 102, 100000));
+        }
+
+        // Process bar with NaN volume
+        var nanBar = new TBar(time.AddMinutes(10), 105, 110, 100, 108, double.NaN);
+        var result = kvo.Update(nanBar);
+
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Update_ZeroPriceRange_HandlesGracefully()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        // First bar normal
+        kvo.Update(new TBar(time, 100, 110, 90, 105, 100000));
+
+        // Bar with zero range
+        var result = kvo.Update(new TBar(time.AddMinutes(1), 105, 105, 105, 105, 100000));
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Update_ZeroVolume_HandlesGracefully()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        kvo.Update(new TBar(time, 100, 110, 90, 105, 100000));
+        var result = kvo.Update(new TBar(time.AddMinutes(1), 105, 115, 95, 110, 0));
+
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Signal_CalculatedAlongsideKvo()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        for (int i = 0; i < 20; i++)
+        {
+            kvo.Update(new TBar(time.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 100000 + i * 10000));
+        }
+
+        Assert.True(double.IsFinite(kvo.Signal.Value));
+        Assert.Equal(kvo.Last.Time, kvo.Signal.Time);
+    }
+
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var kvo = new Kvo(fastPeriod: 3, slowPeriod: 5, signalPeriod: 3);
+        var time = DateTime.UtcNow;
+
+        // Process many bars until IsHot becomes true
+        for (int i = 0; i < 100; i++)
+        {
+            kvo.Update(new TBar(time.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 100000), isNew: true);
+        }
+
+        // Verify indicator was active
+        Assert.True(double.IsFinite(kvo.Last.Value));
+
+        kvo.Reset();
+
+        Assert.False(kvo.IsHot);
+        Assert.Equal(default, kvo.Last);
+        Assert.Equal(default, kvo.Signal);
+    }
+
+    [Fact]
+    public void UpdateWithSignal_ReturnsBothSeries()
+    {
+        var bars = new TBarSeries();
+        var gbm = new GBM(seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            bars.Add(gbm.Next());
+        }
+
+        var kvo = new Kvo();
+        var (kvoSeries, signalSeries) = kvo.UpdateWithSignal(bars);
+
+        Assert.Equal(bars.Count, kvoSeries.Count);
+        Assert.Equal(bars.Count, signalSeries.Count);
+
+        // Verify values are finite
+        for (int i = 0; i < bars.Count; i++)
+        {
+            Assert.True(double.IsFinite(kvoSeries[i].Value));
+            Assert.True(double.IsFinite(signalSeries[i].Value));
+        }
+    }
+
+    [Fact]
+    public void BatchCalculate_MatchesStreaming()
+    {
+        var bars = new TBarSeries();
+        var gbm = new GBM(seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            bars.Add(gbm.Next());
+        }
+
+        // Streaming
+        var kvo = new Kvo();
+        var streamingValues = new List<double>();
+        foreach (var bar in bars)
+        {
+            streamingValues.Add(kvo.Update(bar).Value);
+        }
+
+        // Batch
+        var batchResult = Kvo.Batch(bars);
+
+        Assert.Equal(bars.Count, batchResult.Count);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            Assert.Equal(streamingValues[i], batchResult[i].Value, 10);
+        }
+    }
+
+    [Fact]
+    public void SpanCalculate_MatchesStreaming()
+    {
+        var bars = new TBarSeries();
+        var gbm = new GBM(seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            bars.Add(gbm.Next());
+        }
+
+        // Streaming
+        var kvo = new Kvo();
+        var streamingKvo = new List<double>();
+        var streamingSignal = new List<double>();
+        foreach (var bar in bars)
+        {
+            kvo.Update(bar);
+            streamingKvo.Add(kvo.Last.Value);
+            streamingSignal.Add(kvo.Signal.Value);
+        }
+
+        // Span
+        var high = bars.High.Values.ToArray();
+        var low = bars.Low.Values.ToArray();
+        var close = bars.Close.Values.ToArray();
+        var volume = bars.Volume.Values.ToArray();
+        var spanKvo = new double[bars.Count];
+        var spanSignal = new double[bars.Count];
+
+        Kvo.Batch(high, low, close, volume, spanKvo, spanSignal);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            Assert.Equal(streamingKvo[i], spanKvo[i], 10);
+            Assert.Equal(streamingSignal[i], spanSignal[i], 10);
+        }
+    }
+
+    [Fact]
+    public void SpanCalculate_InvalidLengths_ThrowsArgumentException()
+    {
+        var high = new double[100];
+        var low = new double[99]; // Different length
+        var close = new double[100];
+        var volume = new double[100];
+        var output = new double[100];
+        var signal = new double[100];
+
+        Assert.Throws<ArgumentException>(() => Kvo.Batch(high, low, close, volume, output, signal));
+    }
+
+    [Fact]
+    public void SpanCalculate_InvalidFastPeriod_ThrowsArgumentException()
+    {
+        var high = new double[100];
+        var low = new double[100];
+        var close = new double[100];
+        var volume = new double[100];
+        var output = new double[100];
+        var signal = new double[100];
+
+        Assert.Throws<ArgumentException>(() => Kvo.Batch(high, low, close, volume, output, signal, fastPeriod: 0));
+    }
+
+    [Fact]
+    public void SpanCalculate_InvalidSlowPeriod_ThrowsArgumentException()
+    {
+        var high = new double[100];
+        var low = new double[100];
+        var close = new double[100];
+        var volume = new double[100];
+        var output = new double[100];
+        var signal = new double[100];
+
+        Assert.Throws<ArgumentException>(() => Kvo.Batch(high, low, close, volume, output, signal, slowPeriod: 0));
+    }
+
+    [Fact]
+    public void SpanCalculate_InvalidSignalPeriod_ThrowsArgumentException()
+    {
+        var high = new double[100];
+        var low = new double[100];
+        var close = new double[100];
+        var volume = new double[100];
+        var output = new double[100];
+        var signal = new double[100];
+
+        Assert.Throws<ArgumentException>(() => Kvo.Batch(high, low, close, volume, output, signal, signalPeriod: 0));
+    }
+
+    [Fact]
+    public void SpanCalculate_EmptyInput_HandlesGracefully()
+    {
+        var high = Array.Empty<double>();
+        var low = Array.Empty<double>();
+        var close = Array.Empty<double>();
+        var volume = Array.Empty<double>();
+        var output = Array.Empty<double>();
+        var signal = Array.Empty<double>();
+
+        // Should not throw
+        Kvo.Batch(high, low, close, volume, output, signal);
+
+        // Verify arrays remain empty (no out-of-bounds writes)
+        Assert.Empty(output);
+        Assert.Empty(signal);
+    }
+
+    [Fact]
+    public void Event_PubFiresOnUpdate()
+    {
+        var kvo = new Kvo();
+        TValue? receivedValue = null;
+        bool receivedIsNew = false;
+
+        kvo.Pub += (object? sender, in TValueEventArgs args) =>
+        {
+            receivedValue = args.Value;
+            receivedIsNew = args.IsNew;
+        };
+
+        var bar = new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000000);
+        kvo.Update(bar, isNew: true);
+
+        Assert.NotNull(receivedValue);
+        Assert.True(receivedIsNew);
+    }
+
+    [Fact]
+    public void TrendDetection_CorrectlyIdentifiesTrend()
+    {
+        var kvo = new Kvo(fastPeriod: 2, slowPeriod: 3, signalPeriod: 2);
+        var time = DateTime.UtcNow;
+
+        // First bar - no previous HLC3, trend defaults to +1
+        var result1 = kvo.Update(new TBar(time, 100, 105, 95, 100, 100000));
+
+        // Second bar - HLC3 higher than first (trend = +1)
+        var result2 = kvo.Update(new TBar(time.AddMinutes(1), 105, 115, 100, 110, 100000));
+
+        // Third bar - HLC3 lower than second (trend = -1)
+        var result3 = kvo.Update(new TBar(time.AddMinutes(2), 105, 108, 90, 95, 100000));
+
+        // All values should be finite
+        Assert.True(double.IsFinite(result1.Value));
+        Assert.True(double.IsFinite(result2.Value));
+        Assert.True(double.IsFinite(result3.Value));
+    }
+
+    [Fact]
+    public void CustomPeriods_AffectsResults()
+    {
+        var bars = new TBarSeries();
+        var gbm = new GBM(seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            bars.Add(gbm.Next());
+        }
+
+        var kvo1 = new Kvo(fastPeriod: 10, slowPeriod: 20, signalPeriod: 5);
+        var kvo2 = new Kvo(fastPeriod: 20, slowPeriod: 40, signalPeriod: 10);
+
+        foreach (var bar in bars)
+        {
+            kvo1.Update(bar);
+            kvo2.Update(bar);
+        }
+
+        // Different periods should produce different results
+        Assert.NotEqual(kvo1.Last.Value, kvo2.Last.Value);
+    }
+
+    [Fact]
+    public void LargeDataset_HandlesWithoutError()
+    {
+        var bars = new TBarSeries();
+        var gbm = new GBM(seed: 42);
+
+        for (int i = 0; i < 10000; i++)
+        {
+            bars.Add(gbm.Next());
+        }
+
+        var kvo = new Kvo();
+        foreach (var bar in bars)
+        {
+            var result = kvo.Update(bar);
+            Assert.True(double.IsFinite(result.Value));
+        }
+
+        Assert.True(kvo.IsHot);
+    }
+}
@@ -0,0 +1,397 @@
+using OoplesFinance.StockIndicators;
+using OoplesFinance.StockIndicators.Models;
+using Skender.Stock.Indicators;
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+/// <summary>
+/// Klinger Volume Oscillator validation tests.
+/// Cross-validated against: Skender (GetKvo), Tulip (kvo).
+/// TA-Lib and Ooples do not have KVO implementations.
+///
+/// NOTE: QuanTAlib KVO normalizes the Volume Force differently than Skender and Tulip.
+/// QuanTAlib uses a normalized volume force calculation that produces values in a
+/// different scale (~20) compared to Skender (~27000) and Tulip (~465).
+/// The underlying EMA smoothing logic is the same, so directional agreement
+/// (sign of oscillator changes) should match strongly.
+/// </summary>
+public sealed class KvoValidationTests : IDisposable
+{
+    private readonly ValidationTestData _data;
+    private readonly ITestOutputHelper _output;
+    private const int DefaultFastPeriod = 34;
+    private const int DefaultSlowPeriod = 55;
+    private const int DefaultSignalPeriod = 13;
+
+    public KvoValidationTests(ITestOutputHelper output)
+    {
+        _data = new ValidationTestData();
+        _output = output;
+    }
+
+    public void Dispose() { /* nothing to dispose */ }
+
+    #region Skender Cross Validation Tests
+
+    [Fact]
+    public void Validate_Skender_KVO_Oscillator()
+    {
+        // Skender KVO — Volume Force uses raw volume × trend direction
+        // QuanTAlib KVO — Volume Force uses normalized calculation
+        // Values differ in magnitude but should agree on direction (sign changes)
+        var sResult = _data.SkenderQuotes
+            .GetKvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod)
+            .ToList();
+
+        // QuanTAlib KVO
+        var kvo = new Kvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+        var qValues = new List<double>();
+        foreach (var bar in _data.Bars)
+        {
+            qValues.Add(kvo.Update(bar).Value);
+        }
+
+        // Compare sign of bar-over-bar changes after warmup
+        int compared = 0;
+        int agreed = 0;
+        int startIdx = DefaultSlowPeriod + 50; // skip EMA convergence period
+
+        for (int i = startIdx + 1; i < sResult.Count; i++)
+        {
+            if (!sResult[i].Oscillator.HasValue || !sResult[i - 1].Oscillator.HasValue)
+            {
+                continue;
+            }
+
+            double sDelta = sResult[i].Oscillator!.Value - sResult[i - 1].Oscillator!.Value;
+            double qDelta = qValues[i] - qValues[i - 1];
+
+            // Skip near-zero deltas (ambiguous direction)
+            if (Math.Abs(sDelta) < 1e-6 || Math.Abs(qDelta) < 1e-10)
+            {
+                compared++;
+                agreed++;
+                continue;
+            }
+
+            compared++;
+            if (Math.Sign(qDelta) == Math.Sign(sDelta))
+            {
+                agreed++;
+            }
+        }
+
+        double agreementRate = compared > 0 ? (double)agreed / compared : 0;
+        _output.WriteLine($"KVO Oscillator directional agreement: {agreed}/{compared} = {agreementRate:P1}");
+
+        // Both use EMA(fast) - EMA(slow) on volume force, direction should correlate
+        Assert.True(agreementRate > 0.70,
+            $"KVO oscillator directional agreement should exceed 70%, got {agreementRate:P1}");
+        Assert.True(compared > 100, $"Should compare at least 100 values, got {compared}");
+    }
+
+    [Fact]
+    public void Validate_Skender_KVO_Signal()
+    {
+        // Compare signal line directional agreement
+        var sResult = _data.SkenderQuotes
+            .GetKvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod)
+            .ToList();
+
+        // QuanTAlib KVO
+        var kvo = new Kvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+        var qSignals = new List<double>();
+        foreach (var bar in _data.Bars)
+        {
+            kvo.Update(bar);
+            qSignals.Add(kvo.Signal.Value);
+        }
+
+        // Compare sign of bar-over-bar signal changes
+        int compared = 0;
+        int agreed = 0;
+        int startIdx = DefaultSlowPeriod + DefaultSignalPeriod + 50;
+
+        for (int i = startIdx + 1; i < sResult.Count; i++)
+        {
+            if (!sResult[i].Signal.HasValue || !sResult[i - 1].Signal.HasValue)
+            {
+                continue;
+            }
+
+            double sDelta = sResult[i].Signal!.Value - sResult[i - 1].Signal!.Value;
+            double qDelta = qSignals[i] - qSignals[i - 1];
+
+            if (Math.Abs(sDelta) < 1e-6 || Math.Abs(qDelta) < 1e-10)
+            {
+                compared++;
+                agreed++;
+                continue;
+            }
+
+            compared++;
+            if (Math.Sign(qDelta) == Math.Sign(sDelta))
+            {
+                agreed++;
+            }
+        }
+
+        double agreementRate = compared > 0 ? (double)agreed / compared : 0;
+        _output.WriteLine($"KVO Signal directional agreement: {agreed}/{compared} = {agreementRate:P1}");
+
+        Assert.True(agreementRate > 0.70,
+            $"KVO signal directional agreement should exceed 70%, got {agreementRate:P1}");
+        Assert.True(compared > 100, $"Should compare at least 100 values, got {compared}");
+    }
+
+    [Fact]
+    public void Validate_Skender_KVO_MultiplePeriods()
+    {
+        // Verify directional agreement across multiple period configurations
+        int[][] periodSets = { new[] { 20, 40, 10 }, new[] { 34, 55, 13 }, new[] { 50, 80, 20 } };
+
+        foreach (var periods in periodSets)
+        {
+            int fast = periods[0], slow = periods[1], signal = periods[2];
+
+            var sResult = _data.SkenderQuotes.GetKvo(fast, slow, signal).ToList();
+
+            var kvo = new Kvo(fast, slow, signal);
+            var qValues = new List<double>();
+            foreach (var bar in _data.Bars)
+            {
+                qValues.Add(kvo.Update(bar).Value);
+            }
+
+            int compared = 0;
+            int agreed = 0;
+            int startIdx = slow + 50;
+
+            for (int i = startIdx + 1; i < sResult.Count; i++)
+            {
+                if (!sResult[i].Oscillator.HasValue || !sResult[i - 1].Oscillator.HasValue)
+                {
+                    continue;
+                }
+
+                double sDelta = sResult[i].Oscillator!.Value - sResult[i - 1].Oscillator!.Value;
+                double qDelta = qValues[i] - qValues[i - 1];
+
+                if (Math.Abs(sDelta) < 1e-6 || Math.Abs(qDelta) < 1e-10)
+                {
+                    compared++;
+                    agreed++;
+                    continue;
+                }
+
+                compared++;
+                if (Math.Sign(qDelta) == Math.Sign(sDelta))
+                {
+                    agreed++;
+                }
+            }
+
+            double agreementRate = compared > 0 ? (double)agreed / compared : 0;
+            _output.WriteLine($"KVO({fast},{slow},{signal}): directional agreement {agreed}/{compared} = {agreementRate:P1}");
+
+            Assert.True(agreementRate > 0.70,
+                $"KVO({fast},{slow},{signal}) directional agreement should exceed 70%, got {agreementRate:P1}");
+            Assert.True(compared > 50, $"KVO({fast},{slow},{signal}): Should compare at least 50 values");
+        }
+    }
+
+    #endregion
+
+    #region Tulip Cross Validation Tests
+
+    [Fact]
+    public void Validate_Tulip_KVO()
+    {
+        // Tulip kvo: inputs={high, low, close, volume}, options={short_period, long_period}, outputs={kvo}
+        // Tulip also uses a different Volume Force normalization than QuanTAlib
+        var high = _data.Bars.High.Values.ToArray();
+        var low = _data.Bars.Low.Values.ToArray();
+        var close = _data.Bars.Close.Values.ToArray();
+        var volume = _data.Bars.Volume.Values.ToArray();
+
+        var tulipIndicator = Tulip.Indicators.kvo;
+        double[][] inputs = { high, low, close, volume };
+        double[] options = { DefaultFastPeriod, DefaultSlowPeriod };
+        double[][] outputs = { new double[high.Length] };
+
+        tulipIndicator.Run(inputs, options, outputs);
+        double[] tResult = outputs[0];
+
+        // QuanTAlib KVO
+        var kvo = new Kvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+        var qValues = new double[_data.Bars.Count];
+        int idx = 0;
+        foreach (var bar in _data.Bars)
+        {
+            qValues[idx++] = kvo.Update(bar).Value;
+        }
+
+        int lookback = tulipIndicator.Start(options);
+        _output.WriteLine($"Tulip KVO lookback: {lookback}, output length: {tResult.Length}");
+
+        // Compare bar-over-bar directional agreement
+        int compared = 0;
+        int agreed = 0;
+        int startIdx = Math.Max(lookback + 50, DefaultSlowPeriod + 50);
+
+        for (int i = startIdx + 1; i < qValues.Length && (i - lookback) < tResult.Length; i++)
+        {
+            int tIdx = i - lookback;
+            if (tIdx < 1)
+            {
+                continue;
+            }
+
+            double qDelta = qValues[i] - qValues[i - 1];
+            double tDelta = tResult[tIdx] - tResult[tIdx - 1];
+
+            if (Math.Abs(tDelta) < 1e-6 || Math.Abs(qDelta) < 1e-10)
+            {
+                compared++;
+                agreed++;
+                continue;
+            }
+
+            compared++;
+            if (Math.Sign(qDelta) == Math.Sign(tDelta))
+            {
+                agreed++;
+            }
+        }
+
+        double agreementRate = compared > 0 ? (double)agreed / compared : 0;
+        _output.WriteLine($"Tulip KVO directional agreement: {agreed}/{compared} = {agreementRate:P1}");
+
+        Assert.True(agreementRate > 0.70,
+            $"KVO directional agreement with Tulip should exceed 70%, got {agreementRate:P1}");
+        Assert.True(compared > 50, $"Should compare at least 50 values, got {compared}");
+    }
+
+    #endregion
+
+    [Fact]
+    public void Kvo_Matches_Talib()
+    {
+        // TA-Lib does not have KVO/Klinger Volume Oscillator
+        Assert.True(true, "TA-Lib does not have a Klinger Volume Oscillator implementation");
+    }
+
+    [Fact]
+    public void Kvo_Streaming_Matches_Batch()
+    {
+        // Streaming
+        var kvo = new Kvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+        var streamingValues = new List<double>();
+        foreach (var bar in _data.Bars)
+        {
+            streamingValues.Add(kvo.Update(bar).Value);
+        }
+
+        // Batch
+        var batchResult = Kvo.Batch(_data.Bars, DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+        var batchValues = batchResult.Values.ToArray();
+
+        ValidationHelper.VerifyData(streamingValues.ToArray(), batchValues, 0, 100, 1e-9);
+    }
+
+    [Fact]
+    public void Kvo_Span_Matches_Streaming()
+    {
+        // Streaming
+        var kvo = new Kvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+        var streamingKvo = new List<double>();
+        var streamingSignal = new List<double>();
+        foreach (var bar in _data.Bars)
+        {
+            kvo.Update(bar);
+            streamingKvo.Add(kvo.Last.Value);
+            streamingSignal.Add(kvo.Signal.Value);
+        }
+
+        // Span
+        var high = _data.Bars.High.Values.ToArray();
+        var low = _data.Bars.Low.Values.ToArray();
+        var close = _data.Bars.Close.Values.ToArray();
+        var volume = _data.Bars.Volume.Values.ToArray();
+        var spanKvo = new double[high.Length];
+        var spanSignal = new double[high.Length];
+
+        Kvo.Batch(high, low, close, volume, spanKvo, spanSignal, DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+
+        ValidationHelper.VerifyData(streamingKvo.ToArray(), spanKvo, 0, 100, 1e-9);
+        ValidationHelper.VerifyData(streamingSignal.ToArray(), spanSignal, 0, 100, 1e-9);
+    }
+
+    [Fact]
+    public void Kvo_Signal_Streaming_Matches_Batch()
+    {
+        // Streaming
+        var kvo = new Kvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod);
+        var streamingSignal = new List<double>();
+        foreach (var bar in _data.Bars)
+        {
+            kvo.Update(bar);
+            streamingSignal.Add(kvo.Signal.Value);
+        }
+
+        // Batch with signal
+        var (_, signalSeries) = new Kvo(DefaultFastPeriod, DefaultSlowPeriod, DefaultSignalPeriod).UpdateWithSignal(_data.Bars);
+        var batchSignal = signalSeries.Values.ToArray();
+
+        ValidationHelper.VerifyData(streamingSignal.ToArray(), batchSignal, 0, 100, 1e-9);
+    }
+
+    [Fact]
+    public void Kvo_Different_Periods_ProduceDifferentResults()
+    {
+        // Test with default periods
+        var kvo1 = new Kvo(34, 55, 13);
+        var values1 = new List<double>();
+        foreach (var bar in _data.Bars)
+        {
+            values1.Add(kvo1.Update(bar).Value);
+        }
+
+        // Test with different periods
+        var kvo2 = new Kvo(20, 40, 10);
+        var values2 = new List<double>();
+        foreach (var bar in _data.Bars)
+        {
+            values2.Add(kvo2.Update(bar).Value);
+        }
+
+        // Values should differ
+        bool allEqual = true;
+        for (int i = 0; i < values1.Count; i++)
+        {
+            if (Math.Abs(values1[i] - values2[i]) > 1e-9)
+            {
+                allEqual = false;
+                break;
+            }
+        }
+
+        Assert.False(allEqual, "Different periods should produce different results");
+    }
+
+    [Fact]
+    public void Kvo_MatchesOoples_Structural()
+    {
+        // CalculateKlingerVolumeOscillator — structural test (different VF normalization)
+        var ooplesData = _data.SkenderQuotes
+            .Select(q => new TickerData { Date = q.Date, Open = (double)q.Open, High = (double)q.High, Low = (double)q.Low, Close = (double)q.Close, Volume = (double)q.Volume })
+            .ToList();
+
+        var result = new StockData(ooplesData).CalculateKlingerVolumeOscillator();
+        var values = result.CustomValuesList;
+
+        int finiteCount = values.Count(v => double.IsFinite(v));
+        Assert.True(finiteCount > 100, $"Expected >100 finite Ooples KVO values, got {finiteCount}");
+    }
+}