adding missing validations

lib/dynamics/ravi/Ravi.Quantower.Tests.cs

@@ -0,0 +1,161 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class RaviIndicatorTests
+{
+    [Fact]
+    public void RaviIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new RaviIndicator();
+
+        Assert.Equal(7, indicator.ShortPeriod);
+        Assert.Equal(65, indicator.LongPeriod);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("RAVI - Chande Range Action Verification Index", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void RaviIndicator_ShortName_IncludesParameters()
+    {
+        var indicator = new RaviIndicator { ShortPeriod = 5, LongPeriod = 50 };
+        indicator.Initialize();
+
+        Assert.Contains("RAVI", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("5", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("50", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void RaviIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new RaviIndicator();
+
+        Assert.Equal(0, RaviIndicator.MinHistoryDepths);
+        Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void RaviIndicator_Initialize_CreatesInternalRavi()
+    {
+        var indicator = new RaviIndicator();
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist (single RAVI line)
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void RaviIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new RaviIndicator { ShortPeriod = 3, LongPeriod = 10 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            double basePrice = 100 + i;
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 5, basePrice + 2, 1000);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double raviVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(raviVal));
+        Assert.True(raviVal >= 0);
+    }
+
+    [Fact]
+    public void RaviIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new RaviIndicator { ShortPeriod = 3, LongPeriod = 10 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            double basePrice = 100 + i;
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 5, basePrice + 2, 1000);
+        }
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Add new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(20), 120, 128, 115, 125, 1500);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void RaviIndicator_DifferentPeriods_Work()
+    {
+        int[][] paramSets = { new[] { 3, 10 }, new[] { 5, 20 }, new[] { 7, 65 } };
+
+        foreach (var ps in paramSets)
+        {
+            var indicator = new RaviIndicator { ShortPeriod = ps[0], LongPeriod = ps[1] };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            for (int i = 0; i < 100; i++)
+            {
+                double basePrice = 100 + i;
+                indicator.HistoricalData.AddBar(now.AddMinutes(i), basePrice, basePrice + 5, basePrice - 5, basePrice + 2, 1000);
+                indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            }
+
+            double raviVal = indicator.LinesSeries[0].GetValue(0);
+            Assert.True(double.IsFinite(raviVal), $"Periods ({ps[0]},{ps[1]}) should produce finite RAVI");
+        }
+    }
+
+    [Fact]
+    public void RaviIndicator_Period_CanBeChanged()
+    {
+        var indicator = new RaviIndicator();
+        Assert.Equal(7, indicator.ShortPeriod);
+        Assert.Equal(65, indicator.LongPeriod);
+
+        indicator.ShortPeriod = 5;
+        indicator.LongPeriod = 50;
+        Assert.Equal(5, indicator.ShortPeriod);
+        Assert.Equal(50, indicator.LongPeriod);
+    }
+
+    [Fact]
+    public void RaviIndicator_ShowColdValues_CanBeToggled()
+    {
+        var indicator = new RaviIndicator();
+        Assert.True(indicator.ShowColdValues);
+
+        indicator.ShowColdValues = false;
+        Assert.False(indicator.ShowColdValues);
+
+        indicator.ShowColdValues = true;
+        Assert.True(indicator.ShowColdValues);
+    }
+
+    [Fact]
+    public void RaviIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new RaviIndicator();
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Ravi.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void RaviIndicator_HasOneLineSeries_WithCorrectName()
+    {
+        var indicator = new RaviIndicator();
+        indicator.Initialize();
+
+        Assert.Single(indicator.LinesSeries);
+        Assert.Equal("RAVI", indicator.LinesSeries[0].Name);
+    }
+}

lib/dynamics/ravi/Ravi.Quantower.cs

@@ -0,0 +1,61 @@
+using System.Drawing;
+using System.Runtime.CompilerServices;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib;
+
+[SkipLocalsInit]
+public sealed class RaviIndicator : Indicator, IWatchlistIndicator
+{
+    [InputParameter("Short Period", sortIndex: 1, 1, 100, 1, 0)]
+    public int ShortPeriod { get; set; } = 7;
+
+    [InputParameter("Long Period", sortIndex: 2, 2, 500, 1, 0)]
+    public int LongPeriod { get; set; } = 65;
+
+    [IndicatorExtensions.DataSourceInput]
+    public SourceType Source { get; set; } = SourceType.Close;
+
+    [InputParameter("Show cold values", sortIndex: 21)]
+    public bool ShowColdValues { get; set; } = true;
+
+    private Ravi _ravi = null!;
+    private readonly LineSeries _raviSeries;
+    private string _sourceName = null!;
+    private Func<IHistoryItem, double> _priceSelector = null!;
+
+    public static int MinHistoryDepths => 0;
+    int IWatchlistIndicator.MinHistoryDepths => MinHistoryDepths;
+
+    public override string ShortName => $"RAVI {ShortPeriod},{LongPeriod}:{_sourceName}";
+    public override string SourceCodeLink => "https://github.com/mihakralj/QuanTAlib/blob/main/lib/dynamics/ravi/Ravi.Quantower.cs";
+
+    public RaviIndicator()
+    {
+        OnBackGround = true;
+        SeparateWindow = true;
+        Name = "RAVI - Chande Range Action Verification Index";
+        Description = "Measures trend strength via |SMA(short) - SMA(long)| / SMA(long) × 100";
+
+        _raviSeries = new LineSeries(name: "RAVI", color: Color.Yellow, width: 2, style: LineStyle.Solid);
+        AddLineSeries(_raviSeries);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override void OnInit()
+    {
+        _priceSelector = Source.GetPriceSelector();
+        _sourceName = Source.ToString();
+        _ravi = new Ravi(ShortPeriod, LongPeriod);
+        base.OnInit();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override void OnUpdate(UpdateArgs args)
+    {
+        bool isNew = args.IsNewBar();
+        var item = HistoricalData[Count - 1, SeekOriginHistory.Begin];
+        double value = _ravi.Update(new TValue(item.TimeLeft.Ticks, _priceSelector(item)), isNew).Value;
+        _raviSeries.SetValue(value, _ravi.IsHot, ShowColdValues);
+    }
+}

lib/dynamics/ravi/Ravi.Tests.cs

@@ -0,0 +1,683 @@
+namespace QuanTAlib.Tests;
+
+public class RaviTests
+{
+    // ============== A) Constructor & Parameter Validation ==============
+
+    [Fact]
+    public void Constructor_ValidatesShortPeriod()
+    {
+        Assert.Throws<ArgumentException>(() => new Ravi(0, 65));
+        Assert.Throws<ArgumentException>(() => new Ravi(-1, 65));
+        Assert.Throws<ArgumentException>(() => new Ravi(-100, 65));
+    }
+
+    [Fact]
+    public void Constructor_ValidatesLongPeriod()
+    {
+        Assert.Throws<ArgumentException>(() => new Ravi(7, 0));
+        Assert.Throws<ArgumentException>(() => new Ravi(7, -1));
+    }
+
+    [Fact]
+    public void Constructor_ValidatesShortLessThanLong()
+    {
+        Assert.Throws<ArgumentException>(() => new Ravi(10, 10));
+        Assert.Throws<ArgumentException>(() => new Ravi(20, 10));
+    }
+
+    [Fact]
+    public void Constructor_DefaultPeriods_Work()
+    {
+        var ravi = new Ravi();
+        Assert.Contains("7", ravi.Name, StringComparison.Ordinal);
+        Assert.Contains("65", ravi.Name, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Constructor_CustomPeriods_Work()
+    {
+        var ravi = new Ravi(5, 50);
+        Assert.Contains("5", ravi.Name, StringComparison.Ordinal);
+        Assert.Contains("50", ravi.Name, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Constructor_Period1Short_Works()
+    {
+        var ravi = new Ravi(1, 2);
+        Assert.NotNull(ravi);
+    }
+
+    // ============== B) Basic Calculation ==============
+
+    [Fact]
+    public void BasicCalculation_DoesNotCrash()
+    {
+        var ravi = new Ravi(7, 65);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        foreach (var bar in bars)
+        {
+            ravi.Update(new TValue(bar.Time, bar.Close));
+        }
+
+        Assert.True(double.IsFinite(ravi.Last.Value));
+    }
+
+    [Fact]
+    public void Calc_ReturnsValue()
+    {
+        var ravi = new Ravi(3, 10);
+
+        Assert.Equal(0, ravi.Last.Value);
+
+        var result = ravi.Update(new TValue(DateTime.UtcNow, 100));
+
+        Assert.True(double.IsFinite(result.Value));
+        Assert.Equal(result.Value, ravi.Last.Value);
+    }
+
+    [Fact]
+    public void Properties_Accessible()
+    {
+        var ravi = new Ravi(7, 65);
+
+        Assert.Equal(0, ravi.Last.Value);
+        Assert.False(ravi.IsHot);
+        Assert.Contains("Ravi", ravi.Name, StringComparison.Ordinal);
+        Assert.True(ravi.WarmupPeriod > 0);
+        Assert.Equal(65, ravi.WarmupPeriod);
+    }
+
+    [Fact]
+    public void ConstantPrice_ReturnsZeroAfterWarmup()
+    {
+        var ravi = new Ravi(3, 10);
+
+        for (int i = 0; i < 20; i++)
+        {
+            ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(i), 100));
+        }
+
+        Assert.True(ravi.IsHot);
+        Assert.Equal(0.0, ravi.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void OutputAlwaysNonNegative()
+    {
+        var ravi = new Ravi(3, 10);
+        var gbm = new GBM(startPrice: 100.0, mu: -0.5, sigma: 1.0);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        foreach (var bar in bars)
+        {
+            var result = ravi.Update(new TValue(bar.Time, bar.Close));
+            Assert.True(result.Value >= 0, $"RAVI must be non-negative, got {result.Value}");
+        }
+    }
+
+    // ============== C) State Management & Bar Correction ==============
+
+    [Fact]
+    public void Calc_IsNew_AcceptsParameter()
+    {
+        var ravi = new Ravi(3, 10);
+
+        ravi.Update(new TValue(DateTime.UtcNow, 100), isNew: true);
+        ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(1), 105), isNew: true);
+
+        Assert.True(ravi.Last.Value >= 0);
+    }
+
+    [Fact]
+    public void Calc_IsNew_False_UpdatesValue()
+    {
+        var ravi = new Ravi(3, 10);
+        var gbm = new GBM(startPrice: 100.0);
+        var bars = gbm.Fetch(20, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed 15 bars to get past warmup
+        for (int i = 0; i < 15; i++)
+        {
+            ravi.Update(new TValue(bars[i].Time, bars[i].Close), isNew: true);
+        }
+
+        double beforeUpdate = ravi.Last.Value;
+
+        // Correct with a very different value
+        ravi.Update(new TValue(bars[14].Time, bars[14].Close * 2), isNew: false);
+        double afterUpdate = ravi.Last.Value;
+
+        Assert.NotEqual(beforeUpdate, afterUpdate);
+    }
+
+    [Fact]
+    public void IsNew_Consistency()
+    {
+        var ravi = new Ravi(3, 10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(30, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed first 19
+        for (int i = 0; i < 19; i++)
+        {
+            ravi.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+
+        // Feed 20th bar (isNew=true)
+        ravi.Update(new TValue(bars[19].Time, bars[19].Close), true);
+
+        // Correct with modified value (isNew=false)
+        double modifiedClose = bars[19].Close + 50.0;
+        double val2 = ravi.Update(new TValue(bars[19].Time, modifiedClose), false).Value;
+
+        // Create new instance and feed up to modified
+        var ravi2 = new Ravi(3, 10);
+        for (int i = 0; i < 19; i++)
+        {
+            ravi2.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+        double val3 = ravi2.Update(new TValue(bars[19].Time, modifiedClose), true).Value;
+
+        Assert.Equal(val3, val2, 1e-9);
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreToOriginalState()
+    {
+        var ravi = new Ravi(3, 10);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+        var bars = gbm.Fetch(30, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed 15 new values
+        TValue tenthValue = default;
+        for (int i = 0; i < 15; i++)
+        {
+            tenthValue = new TValue(bars[i].Time, bars[i].Close);
+            ravi.Update(tenthValue, isNew: true);
+        }
+
+        // Remember state after 15 values
+        double stateAfter15 = ravi.Last.Value;
+
+        // Generate corrections with isNew=false (different values)
+        for (int i = 15; i < 25; i++)
+        {
+            ravi.Update(new TValue(bars[i].Time, bars[i].Close), isNew: false);
+        }
+
+        // Feed the remembered 15th value again with isNew=false
+        TValue finalResult = ravi.Update(tenthValue, isNew: false);
+
+        // State should match the original state after 15 values
+        Assert.Equal(stateAfter15, finalResult.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Reset_Works()
+    {
+        var ravi = new Ravi(3, 10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        foreach (var bar in bars)
+        {
+            ravi.Update(new TValue(bar.Time, bar.Close));
+        }
+
+        Assert.True(ravi.IsHot);
+
+        ravi.Reset();
+        Assert.Equal(0, ravi.Last.Value);
+        Assert.False(ravi.IsHot);
+
+        // After reset, should accept new values
+        ravi.Update(new TValue(bars[0].Time, bars[0].Close));
+        Assert.True(double.IsFinite(ravi.Last.Value));
+    }
+
+    // ============== D) Warmup & Convergence ==============
+
+    [Fact]
+    public void IsHot_BecomesTrueWhenBufferFull()
+    {
+        var ravi = new Ravi(3, 10);
+
+        Assert.False(ravi.IsHot);
+
+        var baseTime = DateTime.UtcNow;
+        for (int i = 0; i < 9; i++)
+        {
+            ravi.Update(new TValue(baseTime.AddMinutes(i), 100 + i));
+            Assert.False(ravi.IsHot);
+        }
+
+        // 10th value should make it hot (long period = 10)
+        ravi.Update(new TValue(baseTime.AddMinutes(9), 109));
+        Assert.True(ravi.IsHot);
+    }
+
+    [Fact]
+    public void IsHot_IsPeriodDependent()
+    {
+        var ravi7_65 = new Ravi(7, 65);
+        var ravi3_10 = new Ravi(3, 10);
+
+        Assert.Equal(65, ravi7_65.WarmupPeriod);
+        Assert.Equal(10, ravi3_10.WarmupPeriod);
+    }
+
+    // ============== E) NaN/Infinity Handling ==============
+
+    [Fact]
+    public void NaN_Input_UsesLastValidValue()
+    {
+        var ravi = new Ravi(3, 10);
+
+        for (int i = 0; i < 12; i++)
+        {
+            ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(i), 100 + i));
+        }
+
+        // Feed NaN
+        var resultAfterNaN = ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(12), double.NaN));
+
+        Assert.True(double.IsFinite(resultAfterNaN.Value));
+    }
+
+    [Fact]
+    public void Infinity_Input_UsesLastValidValue()
+    {
+        var ravi = new Ravi(3, 10);
+
+        for (int i = 0; i < 12; i++)
+        {
+            ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(i), 100 + i));
+        }
+
+        var resultAfterInf = ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(12), double.PositiveInfinity));
+        Assert.True(double.IsFinite(resultAfterInf.Value));
+
+        var resultAfterNegInf = ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(13), double.NegativeInfinity));
+        Assert.True(double.IsFinite(resultAfterNegInf.Value));
+    }
+
+    [Fact]
+    public void MultipleNaN_ContinuesWithLastValid()
+    {
+        var ravi = new Ravi(3, 10);
+
+        for (int i = 0; i < 12; i++)
+        {
+            ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(i), 100 + i));
+        }
+
+        // Feed several NaN values
+        for (int i = 0; i < 5; i++)
+        {
+            var result = ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(12 + i), double.NaN));
+            Assert.True(double.IsFinite(result.Value));
+        }
+    }
+
+    [Fact]
+    public void BatchNaN_Safe()
+    {
+        var ravi = new Ravi(3, 10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(30, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed normal values
+        for (int i = 0; i < 15; i++)
+        {
+            ravi.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+
+        // Feed NaN values
+        for (int i = 0; i < 5; i++)
+        {
+            var result = ravi.Update(new TValue(DateTime.UtcNow.AddHours(i + 1), double.NaN));
+            Assert.True(double.IsFinite(result.Value));
+        }
+
+        // Resume normal
+        for (int i = 15; i < 25; i++)
+        {
+            var result = ravi.Update(new TValue(bars[i].Time, bars[i].Close));
+            Assert.True(double.IsFinite(result.Value));
+        }
+    }
+
+    // ============== F) Consistency Tests ==============
+
+    [Fact]
+    public void BatchCalc_MatchesIterativeCalc()
+    {
+        var raviIterative = new Ravi(5, 20);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // Iterative
+        var iterativeResults = new TSeries();
+        foreach (var tv in series)
+        {
+            iterativeResults.Add(raviIterative.Update(tv));
+        }
+
+        // Batch
+        var batchResults = Ravi.Batch(series, 5, 20);
+
+        Assert.Equal(iterativeResults.Count, batchResults.Count);
+        for (int i = 0; i < iterativeResults.Count; i++)
+        {
+            Assert.Equal(iterativeResults[i].Value, batchResults[i].Value, 1e-10);
+        }
+    }
+
+    [Fact]
+    public void TSeries_Update_MatchesStreaming()
+    {
+        var ravi1 = new Ravi(5, 20);
+        var ravi2 = new Ravi(5, 20);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // Streaming
+        foreach (var tv in series)
+        {
+            ravi1.Update(tv);
+        }
+
+        // Batch via Update(TSeries)
+        ravi2.Update(series);
+
+        Assert.Equal(ravi1.Last.Value, ravi2.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void SpanBatch_MatchesStreaming()
+    {
+        var ravi = new Ravi(5, 20);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // Streaming
+        var streamResults = new double[100];
+        for (int i = 0; i < 100; i++)
+        {
+            streamResults[i] = ravi.Update(series[i]).Value;
+        }
+
+        // Span batch
+        var values = series.Values.ToArray();
+        var spanResults = new double[100];
+        Ravi.Batch(values, spanResults, 5, 20);
+
+        for (int i = 0; i < 100; i++)
+        {
+            Assert.Equal(streamResults[i], spanResults[i], 1e-10);
+        }
+    }
+
+    [Fact]
+    public void EventBased_MatchesStreaming()
+    {
+        var ravi1 = new Ravi(5, 20);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // Collect event-based results
+        var eventResults = new List<double>();
+        ravi1.Pub += (object? _, in TValueEventArgs e) => eventResults.Add(e.Value.Value);
+
+        foreach (var tv in series)
+        {
+            ravi1.Update(tv);
+        }
+
+        // Collect streaming results
+        var ravi2 = new Ravi(5, 20);
+        var streamResults = new List<double>();
+
+        foreach (var tv in series)
+        {
+            streamResults.Add(ravi2.Update(tv).Value);
+        }
+
+        Assert.Equal(streamResults.Count, eventResults.Count);
+        for (int i = 0; i < streamResults.Count; i++)
+        {
+            Assert.Equal(streamResults[i], eventResults[i], 1e-10);
+        }
+    }
+
+    [Fact]
+    public void AllModes_ProduceSameResult()
+    {
+        int shortP = 5;
+        int longP = 20;
+        var gbm = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.2);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // 1. Batch
+        var batchSeries = Ravi.Batch(series, shortP, longP);
+        double expected = batchSeries.Last.Value;
+
+        // 2. Span
+        var values = series.Values.ToArray();
+        var spanOutput = new double[values.Length];
+        Ravi.Batch(values, spanOutput, shortP, longP);
+        double spanResult = spanOutput[^1];
+
+        // 3. Streaming
+        var streamingInd = new Ravi(shortP, longP);
+        for (int i = 0; i < series.Count; i++)
+        {
+            streamingInd.Update(series[i]);
+        }
+        double streamingResult = streamingInd.Last.Value;
+
+        // 4. Eventing
+        var pubSource = new TSeries();
+        var eventingInd = new Ravi(pubSource, shortP, longP);
+        for (int i = 0; i < series.Count; i++)
+        {
+            pubSource.Add(series[i]);
+        }
+        double eventingResult = eventingInd.Last.Value;
+
+        Assert.Equal(expected, spanResult, 1e-9);
+        Assert.Equal(expected, streamingResult, 1e-9);
+        Assert.Equal(expected, eventingResult, 1e-9);
+    }
+
+    // ============== G) Span API Tests ==============
+
+    [Fact]
+    public void SpanBatch_ValidatesLengths()
+    {
+        double[] source = new double[10];
+        double[] output = new double[5]; // too small
+
+        Assert.Throws<ArgumentException>(() => Ravi.Batch(source, output, 3, 10));
+    }
+
+    [Fact]
+    public void SpanBatch_ValidatesShortPeriod()
+    {
+        double[] source = new double[10];
+        double[] output = new double[10];
+
+        var ex = Assert.Throws<ArgumentException>(() => Ravi.Batch(source, output, 0, 10));
+        Assert.Equal("shortPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void SpanBatch_ValidatesLongPeriod()
+    {
+        double[] source = new double[10];
+        double[] output = new double[10];
+
+        var ex = Assert.Throws<ArgumentException>(() => Ravi.Batch(source, output, 3, 0));
+        Assert.Equal("longPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void SpanBatch_ValidatesShortLessThanLong()
+    {
+        double[] source = new double[10];
+        double[] output = new double[10];
+
+        var ex = Assert.Throws<ArgumentException>(() => Ravi.Batch(source, output, 10, 5));
+        Assert.Equal("shortPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void SpanBatch_EmptyInput_NoOp()
+    {
+        double[] source = Array.Empty<double>();
+        double[] output = Array.Empty<double>();
+
+        var ex = Record.Exception(() => Ravi.Batch(source, output, 3, 10));
+        Assert.Null(ex);
+    }
+
+    [Fact]
+    public void SpanBatch_NaN_HandledGracefully()
+    {
+        double[] source = { 100, 101, double.NaN, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112 };
+        double[] output = new double[source.Length];
+
+        Ravi.Batch(source, output, 3, 10);
+
+        for (int i = 0; i < output.Length; i++)
+        {
+            Assert.True(double.IsFinite(output[i]), $"Output[{i}] should be finite but was {output[i]}");
+        }
+    }
+
+    [Fact]
+    public void SpanBatch_MatchesTSeriesCalc()
+    {
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // TSeries path
+        var tsResults = Ravi.Batch(series, 5, 20);
+
+        // Span path
+        var values = series.Values.ToArray();
+        var spanOutput = new double[values.Length];
+        Ravi.Batch(values, spanOutput, 5, 20);
+
+        for (int i = 0; i < values.Length; i++)
+        {
+            Assert.Equal(tsResults[i].Value, spanOutput[i], 1e-10);
+        }
+    }
+
+    // ============== H) Chainability ==============
+
+    [Fact]
+    public void Chainability_Works()
+    {
+        var ravi = new Ravi(5, 20);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        var result = ravi.Update(series);
+        Assert.Equal(50, result.Count);
+        Assert.Equal(ravi.Last.Value, result.Last.Value);
+    }
+
+    [Fact]
+    public void PubEvent_Fires()
+    {
+        var ravi = new Ravi(3, 10);
+        int eventCount = 0;
+        ravi.Pub += (object? _, in TValueEventArgs _) => eventCount++;
+
+        for (int i = 0; i < 15; i++)
+        {
+            ravi.Update(new TValue(DateTime.UtcNow.AddMinutes(i), 100 + i));
+        }
+
+        Assert.Equal(15, eventCount);
+    }
+
+    [Fact]
+    public void Chaining_ViaConstructor_Works()
+    {
+        // Create a source SMA
+        var sma = new Sma(5);
+        var ravi = new Ravi(sma, 3, 10);
+
+        var gbm = new GBM();
+        var bars = gbm.Fetch(30, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // When SMA updates, chained RAVI should also update
+        foreach (var tv in series)
+        {
+            sma.Update(tv);
+        }
+
+        Assert.True(double.IsFinite(ravi.Last.Value));
+    }
+
+    // ============== RAVI-Specific Tests ==============
+
+    [Fact]
+    public void MonotonicallyIncreasing_ProducesPositiveRavi()
+    {
+        var ravi = new Ravi(3, 10);
+        var baseTime = DateTime.UtcNow;
+
+        // Feed monotonically increasing prices
+        for (int i = 0; i < 20; i++)
+        {
+            ravi.Update(new TValue(baseTime.AddMinutes(i), 100 + i));
+        }
+
+        Assert.True(ravi.IsHot);
+        Assert.True(ravi.Last.Value > 0, $"RAVI should be positive for trending market, got {ravi.Last.Value}");
+    }
+
+    [Fact]
+    public void StaticBatch_Works()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        var results = Ravi.Batch(series, 7, 65);
+
+        Assert.Equal(100, results.Count);
+        Assert.True(double.IsFinite(results.Last.Value));
+    }
+
+    [Fact]
+    public void Calculate_ReturnsResultsAndIndicator()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        var (results, indicator) = Ravi.Calculate(series, 5, 20);
+
+        Assert.Equal(100, results.Count);
+        Assert.NotNull(indicator);
+        Assert.True(double.IsFinite(indicator.Last.Value));
+        Assert.True(indicator.IsHot);
+    }
+}

lib/dynamics/ravi/Ravi.Validation.Tests.cs

@@ -0,0 +1,290 @@
+namespace QuanTAlib.Tests;
+
+/// <summary>
+/// RAVI Validation Tests — Self-consistency validation.
+/// No external library (TA-Lib, Skender, Tulip, Ooples) implements RAVI.
+/// Validation focuses on internal consistency and mathematical correctness.
+/// </summary>
+public sealed class RaviValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private bool _disposed;
+
+    public RaviValidationTests()
+    {
+        _testData = new ValidationTestData();
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+
+        if (disposing)
+        {
+            _testData?.Dispose();
+        }
+    }
+
+    // ============== Self-Consistency ==============
+
+    [Fact]
+    public void Validation_BatchMatchesStreaming()
+    {
+        int[][] paramSets = { new[] { 3, 10 }, new[] { 5, 20 }, new[] { 7, 65 } };
+        var series = _testData.Data;
+
+        foreach (var ps in paramSets)
+        {
+            int shortP = ps[0];
+            int longP = ps[1];
+
+            // Streaming
+            var raviStream = new Ravi(shortP, longP);
+            var streamResults = new List<double>();
+            foreach (var tv in series)
+            {
+                streamResults.Add(raviStream.Update(tv).Value);
+            }
+
+            // Batch
+            var batchResults = Ravi.Batch(series, shortP, longP);
+
+            Assert.Equal(streamResults.Count, batchResults.Count);
+            for (int i = 0; i < streamResults.Count; i++)
+            {
+                Assert.Equal(streamResults[i], batchResults[i].Value, 1e-10);
+            }
+        }
+    }
+
+    [Fact]
+    public void Validation_SpanMatchesStreaming()
+    {
+        int[][] paramSets = { new[] { 3, 10 }, new[] { 5, 20 }, new[] { 7, 65 } };
+        var series = _testData.Data;
+        int len = series.Count;
+
+        double[] values = series.Values.ToArray();
+
+        foreach (var ps in paramSets)
+        {
+            int shortP = ps[0];
+            int longP = ps[1];
+
+            // Streaming
+            var raviStream = new Ravi(shortP, longP);
+            var streamResults = new double[len];
+            for (int i = 0; i < len; i++)
+            {
+                streamResults[i] = raviStream.Update(series[i]).Value;
+            }
+
+            // Span batch
+            double[] spanResults = new double[len];
+            Ravi.Batch(values, spanResults, shortP, longP);
+
+            for (int i = 0; i < len; i++)
+            {
+                Assert.Equal(streamResults[i], spanResults[i], 1e-10);
+            }
+        }
+    }
+
+    // ============== Known-Value Tests ==============
+
+    [Fact]
+    public void Validation_ConstantPrice_ZeroRavi()
+    {
+        var ravi = new Ravi(3, 10);
+        var baseTime = DateTime.UtcNow;
+
+        for (int i = 0; i < 20; i++)
+        {
+            var result = ravi.Update(new TValue(baseTime.AddMinutes(i), 100));
+            if (ravi.IsHot)
+            {
+                Assert.Equal(0.0, result.Value, 1e-10);
+            }
+        }
+    }
+
+    [Fact]
+    public void Validation_EqualPeriods_ThrowsException()
+    {
+        // Short must be strictly less than long — equal throws
+        Assert.Throws<ArgumentException>(() => new Ravi(10, 10));
+    }
+
+    [Fact]
+    public void Validation_WarmupBarsReturnZero()
+    {
+        var ravi = new Ravi(3, 10);
+        var baseTime = DateTime.UtcNow;
+
+        // First 9 bars (before long SMA is full) should return 0
+        for (int i = 0; i < 9; i++)
+        {
+            var result = ravi.Update(new TValue(baseTime.AddMinutes(i), 100 + i));
+            Assert.Equal(0.0, result.Value, 1e-10);
+            Assert.False(ravi.IsHot);
+        }
+    }
+
+    [Fact]
+    public void Validation_DivByZero_ReturnsZero()
+    {
+        // If all prices are 0, SMA_long = 0 → division guard should produce 0
+        var ravi = new Ravi(3, 10);
+        var baseTime = DateTime.UtcNow;
+
+        for (int i = 0; i < 15; i++)
+        {
+            var result = ravi.Update(new TValue(baseTime.AddMinutes(i), 0));
+            Assert.Equal(0.0, result.Value, 1e-10);
+            Assert.True(double.IsFinite(result.Value));
+        }
+    }
+
+    // ============== Different Periods ==============
+
+    [Fact]
+    public void Validation_DifferentPeriods_ProduceDifferentResults()
+    {
+        var ravi_3_10 = new Ravi(3, 10);
+        var ravi_5_20 = new Ravi(5, 20);
+        var ravi_7_65 = new Ravi(7, 65);
+
+        var gbm = new GBM(startPrice: 100.0, mu: 0.1, sigma: 0.3);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        foreach (var tv in series)
+        {
+            ravi_3_10.Update(tv);
+            ravi_5_20.Update(tv);
+            ravi_7_65.Update(tv);
+        }
+
+        // All should be finite and non-negative
+        Assert.True(double.IsFinite(ravi_3_10.Last.Value));
+        Assert.True(double.IsFinite(ravi_5_20.Last.Value));
+        Assert.True(double.IsFinite(ravi_7_65.Last.Value));
+        Assert.True(ravi_3_10.Last.Value >= 0);
+        Assert.True(ravi_5_20.Last.Value >= 0);
+        Assert.True(ravi_7_65.Last.Value >= 0);
+    }
+
+    [Fact]
+    public void Validation_Calculate_ReturnsHotIndicator()
+    {
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.3);
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        var (results, indicator) = Ravi.Calculate(series, 5, 20);
+
+        Assert.Equal(series.Count, results.Count);
+        Assert.True(indicator.IsHot);
+        Assert.True(double.IsFinite(indicator.Last.Value));
+    }
+
+    [Fact]
+    public void Validation_BarCorrection_Consistent()
+    {
+        var ravi1 = new Ravi(5, 20);
+        var ravi2 = new Ravi(5, 20);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.3);
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // Ravi1: feed all values normally
+        foreach (var tv in series)
+        {
+            ravi1.Update(tv, isNew: true);
+        }
+
+        // Ravi2: feed values with correction on last bar
+        for (int i = 0; i < series.Count - 1; i++)
+        {
+            ravi2.Update(series[i], isNew: true);
+        }
+        // Feed wrong last value first
+        ravi2.Update(new TValue(series[^1].Time, 999999), isNew: true);
+        // Correct it
+        ravi2.Update(series[^1], isNew: false);
+
+        Assert.Equal(ravi1.Last.Value, ravi2.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Validation_Ravi_AlwaysNonNegative()
+    {
+        var ravi = new Ravi(7, 65);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.05, sigma: 1.0);
+        var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        foreach (var tv in series)
+        {
+            var result = ravi.Update(tv);
+            Assert.True(result.Value >= 0, $"RAVI must be non-negative, got {result.Value}");
+        }
+    }
+
+    [Fact]
+    public void Validation_Symmetry_UpAndDownTrends()
+    {
+        // A monotonic rise of +1/bar and a monotonic fall of -1/bar
+        // should produce equal RAVI after warmup
+        var raviUp = new Ravi(3, 10);
+        var raviDown = new Ravi(3, 10);
+        var baseTime = DateTime.UtcNow;
+
+        double basePrice = 1000;
+        for (int i = 0; i < 20; i++)
+        {
+            raviUp.Update(new TValue(baseTime.AddMinutes(i), basePrice + i));
+            raviDown.Update(new TValue(baseTime.AddMinutes(i), basePrice - i));
+        }
+
+        // Not exactly equal because normalization denominator differs,
+        // but both should be positive and finite
+        Assert.True(raviUp.Last.Value > 0);
+        Assert.True(raviDown.Last.Value > 0);
+        Assert.True(double.IsFinite(raviUp.Last.Value));
+        Assert.True(double.IsFinite(raviDown.Last.Value));
+    }
+
+    [Fact]
+    public void Validation_ManualKnownValue()
+    {
+        // Manual calculation: 5 bars, shortPeriod=2, longPeriod=5
+        // Prices: 100, 102, 104, 106, 108
+        // After 5 bars:
+        //   SMA_short(2) = (106 + 108) / 2 = 107
+        //   SMA_long(5) = (100 + 102 + 104 + 106 + 108) / 5 = 104
+        //   RAVI = |107 - 104| / 104 * 100 = 3/104 * 100 ≈ 2.884615...
+
+        var ravi = new Ravi(2, 5);
+        var baseTime = DateTime.UtcNow;
+
+        ravi.Update(new TValue(baseTime, 100));
+        ravi.Update(new TValue(baseTime.AddMinutes(1), 102));
+        ravi.Update(new TValue(baseTime.AddMinutes(2), 104));
+        ravi.Update(new TValue(baseTime.AddMinutes(3), 106));
+        ravi.Update(new TValue(baseTime.AddMinutes(4), 108));
+
+        double expected = Math.Abs(107.0 - 104.0) / 104.0 * 100.0;
+        Assert.Equal(expected, ravi.Last.Value, 1e-10);
+    }
+}

lib/dynamics/ravi/Ravi.cs

@@ -0,0 +1,479 @@
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// RAVI: Chande Range Action Verification Index
+/// Measures trend strength by computing the absolute percentage divergence
+/// between a short-period SMA and a long-period SMA.
+/// </summary>
+/// <remarks>
+/// <b>Calculation steps:</b>
+/// <list type="number">
+/// <item>SMA_short = running sum of last shortPeriod closes / shortPeriod</item>
+/// <item>SMA_long = running sum of last longPeriod closes / longPeriod</item>
+/// <item>RAVI = |SMA_short - SMA_long| / |SMA_long| * 100</item>
+/// </list>
+///
+/// <b>Sources:</b>
+/// Tushar Chande, "Beyond Technical Analysis", Wiley, 2nd ed. (2001), pp. 66-70
+/// </remarks>
+/// <seealso href="Ravi.md">Detailed documentation</seealso>
+[SkipLocalsInit]
+public sealed class Ravi : AbstractBase
+{
+    private readonly int _shortPeriod;
+    private readonly int _longPeriod;
+    private readonly RingBuffer _shortBuffer;
+    private readonly RingBuffer _longBuffer;
+
+    [StructLayout(LayoutKind.Auto)]
+    private record struct State(
+        double ShortSum,
+        double LongSum,
+        double LastValidValue,
+        int ShortTickCount,
+        int LongTickCount
+    );
+
+    private State _s;
+    private State _ps;
+
+    private const int ResyncInterval = 1000;
+
+    /// <summary>
+    /// Creates RAVI with specified short and long SMA periods.
+    /// </summary>
+    /// <param name="shortPeriod">Short SMA period (must be &gt; 0, default 7)</param>
+    /// <param name="longPeriod">Long SMA period (must be &gt; shortPeriod, default 65)</param>
+    public Ravi(int shortPeriod = 7, int longPeriod = 65)
+    {
+        if (shortPeriod <= 0)
+        {
+            throw new ArgumentException("Short period must be greater than 0", nameof(shortPeriod));
+        }
+        if (longPeriod <= 0)
+        {
+            throw new ArgumentException("Long period must be greater than 0", nameof(longPeriod));
+        }
+        if (shortPeriod >= longPeriod)
+        {
+            throw new ArgumentException("Short period must be less than long period", nameof(shortPeriod));
+        }
+
+        _shortPeriod = shortPeriod;
+        _longPeriod = longPeriod;
+        _shortBuffer = new RingBuffer(shortPeriod);
+        _longBuffer = new RingBuffer(longPeriod);
+        Name = $"Ravi({shortPeriod},{longPeriod})";
+        WarmupPeriod = longPeriod;
+        _s = new State(0, 0, 0, 0, 0);
+        _ps = _s;
+    }
+
+    /// <summary>
+    /// Creates RAVI with specified source and parameters.
+    /// </summary>
+    public Ravi(ITValuePublisher source, int shortPeriod = 7, int longPeriod = 65) : this(shortPeriod, longPeriod)
+    {
+        source.Pub += Handle;
+    }
+
+    private void Handle(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
+
+    /// <summary>
+    /// True when both SMA buffers are full (long buffer determines warmup).
+    /// </summary>
+    public override bool IsHot => _longBuffer.IsFull;
+
+    /// <summary>
+    /// Updates the indicator with a single TValue input.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override TValue Update(TValue input, bool isNew = true)
+    {
+        if (isNew)
+        {
+            _ps = _s;
+        }
+        else
+        {
+            _s = _ps;
+            // Restore buffer state for bar correction
+            _shortBuffer.UpdateNewest(_shortBuffer.Newest);
+            _longBuffer.UpdateNewest(_longBuffer.Newest);
+        }
+
+        var s = _s;
+
+        // NaN/Infinity handling: last-valid substitution
+        double val = input.Value;
+        if (double.IsFinite(val))
+        {
+            s.LastValidValue = val;
+        }
+        else
+        {
+            val = s.LastValidValue;
+        }
+
+        if (isNew)
+        {
+            // Short buffer: remove oldest, add new
+            double shortRemoved = _shortBuffer.Count == _shortBuffer.Capacity ? _shortBuffer.Oldest : 0.0;
+            s.ShortSum = s.ShortSum - shortRemoved + val;
+            _shortBuffer.Add(val);
+
+            // Long buffer: remove oldest, add new
+            double longRemoved = _longBuffer.Count == _longBuffer.Capacity ? _longBuffer.Oldest : 0.0;
+            s.LongSum = s.LongSum - longRemoved + val;
+            _longBuffer.Add(val);
+
+            // Resync to prevent floating-point drift
+            s.ShortTickCount++;
+            if (_shortBuffer.IsFull && s.ShortTickCount >= ResyncInterval)
+            {
+                s.ShortTickCount = 0;
+                s.ShortSum = _shortBuffer.RecalculateSum();
+            }
+            s.LongTickCount++;
+            if (_longBuffer.IsFull && s.LongTickCount >= ResyncInterval)
+            {
+                s.LongTickCount = 0;
+                s.LongSum = _longBuffer.RecalculateSum();
+            }
+        }
+        else
+        {
+            // Bar correction: update newest value in both buffers
+            _shortBuffer.UpdateNewest(val);
+            s.ShortSum = _shortBuffer.Sum;
+
+            _longBuffer.UpdateNewest(val);
+            s.LongSum = _longBuffer.Sum;
+        }
+
+        // Calculate RAVI
+        double result;
+        if (_longBuffer.IsFull && _shortBuffer.IsFull)
+        {
+            double smaShort = s.ShortSum / _shortPeriod;
+            double smaLong = s.LongSum / _longPeriod;
+            double absSmaLong = Math.Abs(smaLong);
+
+            // Division-by-zero guard
+            if (absSmaLong > 1e-10)
+            {
+                result = Math.Abs(smaShort - smaLong) / absSmaLong * 100.0;
+            }
+            else
+            {
+                result = 0.0;
+            }
+        }
+        else
+        {
+            result = 0.0;
+        }
+
+        _s = s;
+
+        Last = new TValue(input.Time, result);
+        PubEvent(Last, isNew);
+        return Last;
+    }
+
+    /// <inheritdoc/>
+    public override TSeries Update(TSeries source)
+    {
+        if (source.Count == 0)
+        {
+            return [];
+        }
+
+        int len = source.Count;
+        var t = new List<long>(len);
+        var v = new List<double>(len);
+        CollectionsMarshal.SetCount(t, len);
+        CollectionsMarshal.SetCount(v, len);
+
+        var tSpan = CollectionsMarshal.AsSpan(t);
+        var vSpan = CollectionsMarshal.AsSpan(v);
+
+        Batch(source.Values, vSpan, _shortPeriod, _longPeriod);
+        source.Times.CopyTo(tSpan);
+
+        // Prime internal state by replaying last longPeriod bars
+        Prime(source.Values);
+
+        Last = new TValue(tSpan[len - 1], vSpan[len - 1]);
+        return new TSeries(t, v);
+    }
+
+    /// <inheritdoc/>
+    public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
+    {
+        if (source.Length == 0)
+        {
+            return;
+        }
+
+        _shortBuffer.Clear();
+        _longBuffer.Clear();
+        _s = default;
+        _ps = default;
+
+        int warmupLength = Math.Min(source.Length, WarmupPeriod);
+        int startIndex = source.Length - warmupLength;
+
+        // Seed LastValidValue
+        _s.LastValidValue = 0;
+        for (int i = startIndex - 1; i >= 0; i--)
+        {
+            if (double.IsFinite(source[i]))
+            {
+                _s.LastValidValue = source[i];
+                break;
+            }
+        }
+
+        if (_s.LastValidValue == 0)
+        {
+            for (int i = startIndex; i < source.Length; i++)
+            {
+                if (double.IsFinite(source[i]))
+                {
+                    _s.LastValidValue = source[i];
+                    break;
+                }
+            }
+        }
+
+        for (int i = startIndex; i < source.Length; i++)
+        {
+            Update(new TValue(DateTime.MinValue, source[i]), isNew: true);
+        }
+
+        _ps = _s;
+    }
+
+    /// <summary>
+    /// Calculates RAVI for the entire series using a new instance.
+    /// </summary>
+    public static TSeries Batch(TSeries source, int shortPeriod = 7, int longPeriod = 65)
+    {
+        var ravi = new Ravi(shortPeriod, longPeriod);
+        return ravi.Update(source);
+    }
+
+    /// <summary>
+    /// Span-based batch calculation for close price arrays.
+    /// Zero-allocation method for maximum performance.
+    /// </summary>
+    /// <param name="source">Close prices.</param>
+    /// <param name="output">Output RAVI values.</param>
+    /// <param name="shortPeriod">Short SMA period.</param>
+    /// <param name="longPeriod">Long SMA period.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Batch(ReadOnlySpan<double> source, Span<double> output, int shortPeriod = 7, int longPeriod = 65)
+    {
+        if (source.Length != output.Length)
+        {
+            throw new ArgumentException("Source and output must have the same length", nameof(output));
+        }
+        if (shortPeriod <= 0)
+        {
+            throw new ArgumentException("Short period must be greater than 0", nameof(shortPeriod));
+        }
+        if (longPeriod <= 0)
+        {
+            throw new ArgumentException("Long period must be greater than 0", nameof(longPeriod));
+        }
+        if (shortPeriod >= longPeriod)
+        {
+            throw new ArgumentException("Short period must be less than long period", nameof(shortPeriod));
+        }
+
+        int len = source.Length;
+        if (len == 0)
+        {
+            return;
+        }
+
+        CalculateScalarCore(source, output, shortPeriod, longPeriod);
+    }
+
+    /// <summary>
+    /// Calculates RAVI and returns both results and the indicator instance.
+    /// </summary>
+    public static (TSeries Results, Ravi Indicator) Calculate(TSeries source, int shortPeriod = 7, int longPeriod = 65)
+    {
+        var indicator = new Ravi(shortPeriod, longPeriod);
+        TSeries results = indicator.Update(source);
+        return (results, indicator);
+    }
+
+    // ---- Private implementation ----
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void CalculateScalarCore(ReadOnlySpan<double> source, Span<double> output, int shortPeriod, int longPeriod)
+    {
+        int len = source.Length;
+
+        const int StackAllocThreshold = 256;
+
+        // Short buffer
+        double[]? rentedShort = shortPeriod > StackAllocThreshold ? ArrayPool<double>.Shared.Rent(shortPeriod) : null;
+        Span<double> shortBuf = rentedShort != null
+            ? rentedShort.AsSpan(0, shortPeriod)
+            : stackalloc double[shortPeriod];
+
+        // Long buffer
+        double[]? rentedLong = longPeriod > StackAllocThreshold ? ArrayPool<double>.Shared.Rent(longPeriod) : null;
+        Span<double> longBuf = rentedLong != null
+            ? rentedLong.AsSpan(0, longPeriod)
+            : stackalloc double[longPeriod];
+
+        try
+        {
+            double shortSum = 0;
+            double longSum = 0;
+            double lastValid = 0;
+            int shortIdx = 0;
+            int longIdx = 0;
+            int shortFilled = 0;
+            int longFilled = 0;
+
+            // Find first valid value to seed lastValid
+            for (int k = 0; k < len; k++)
+            {
+                if (double.IsFinite(source[k]))
+                {
+                    lastValid = source[k];
+                    break;
+                }
+            }
+
+            int shortTickCount = 0;
+            int longTickCount = 0;
+
+            for (int i = 0; i < len; i++)
+            {
+                double val = source[i];
+                if (double.IsFinite(val))
+                {
+                    lastValid = val;
+                }
+                else
+                {
+                    val = lastValid;
+                }
+
+                // Update short buffer
+                if (shortFilled >= shortPeriod)
+                {
+                    shortSum -= shortBuf[shortIdx];
+                }
+                shortSum += val;
+                shortBuf[shortIdx] = val;
+                if (shortFilled < shortPeriod)
+                {
+                    shortFilled++;
+                }
+                shortIdx++;
+                if (shortIdx >= shortPeriod)
+                {
+                    shortIdx = 0;
+                }
+
+                // Update long buffer
+                if (longFilled >= longPeriod)
+                {
+                    longSum -= longBuf[longIdx];
+                }
+                longSum += val;
+                longBuf[longIdx] = val;
+                if (longFilled < longPeriod)
+                {
+                    longFilled++;
+                }
+                longIdx++;
+                if (longIdx >= longPeriod)
+                {
+                    longIdx = 0;
+                }
+
+                // Resync short
+                shortTickCount++;
+                if (shortFilled >= shortPeriod && shortTickCount >= ResyncInterval)
+                {
+                    shortTickCount = 0;
+                    double recalc = 0;
+                    for (int k = 0; k < shortPeriod; k++)
+                    {
+                        recalc += shortBuf[k];
+                    }
+                    shortSum = recalc;
+                }
+
+                // Resync long
+                longTickCount++;
+                if (longFilled >= longPeriod && longTickCount >= ResyncInterval)
+                {
+                    longTickCount = 0;
+                    double recalc = 0;
+                    for (int k = 0; k < longPeriod; k++)
+                    {
+                        recalc += longBuf[k];
+                    }
+                    longSum = recalc;
+                }
+
+                // Calculate RAVI
+                if (shortFilled >= shortPeriod && longFilled >= longPeriod)
+                {
+                    double smaShort = shortSum / shortPeriod;
+                    double smaLong = longSum / longPeriod;
+                    double absSmaLong = Math.Abs(smaLong);
+
+                    if (absSmaLong > 1e-10)
+                    {
+                        output[i] = Math.Abs(smaShort - smaLong) / absSmaLong * 100.0;
+                    }
+                    else
+                    {
+                        output[i] = 0.0;
+                    }
+                }
+                else
+                {
+                    output[i] = 0.0;
+                }
+            }
+        }
+        finally
+        {
+            if (rentedShort != null)
+            {
+                ArrayPool<double>.Shared.Return(rentedShort);
+            }
+            if (rentedLong != null)
+            {
+                ArrayPool<double>.Shared.Return(rentedLong);
+            }
+        }
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override void Reset()
+    {
+        _shortBuffer.Clear();
+        _longBuffer.Clear();
+        _s = new State(0, 0, 0, 0, 0);
+        _ps = _s;
+        Last = default;
+    }
+}

lib/dynamics/ravi/Ravi.md

@@ -0,0 +1,234 @@
+# RAVI: Chande Range Action Verification Index
+
+> "The simplest question in technical analysis is also the most important: is this market trending or not? RAVI answers it with two moving averages and a division."
+
+RAVI (Range Action Verification Index) measures trend strength by computing the absolute percentage divergence between a short-period SMA and a long-period SMA. Created by Tushar Chande and published in *Beyond Technical Analysis* (Wiley, 2001), the indicator classifies markets into trending (RAVI > 3%) and ranging (RAVI < 3%) regimes using a single threshold. With default parameters (short=7, long=65), RAVI requires 65 bars of warmup for the first valid reading. The core computation is three operations per bar in streaming mode: two running-sum updates and one division. No square roots, no exponentials, no recursion. The entire indicator reduces to normalized SMA spread, making it one of the cheapest dynamics classifiers available.
+
+## Historical Context
+
+Tushar Chande holds a PhD in engineering and has spent decades building quantitative tools for traders. His most cited work, VIDYA (Variable Index Dynamic Average), appeared in *Stocks & Commodities* in 1992, introducing the concept of volatility-adaptive smoothing constants. RAVI emerged from the same intellectual thread: if short-term and long-term averages agree on price, the market is going nowhere; if they disagree, something directional is happening.
+
+Chande designed RAVI as a simpler alternative to Wilder's ADX. ADX requires True Range, Directional Movement (+DM/-DM), three separate Wilder smoothings, and a final DX-to-ADX smoothing pass. The computation chain is deep and the warmup period is substantial (Wilder recommended 2N bars for ADX with period N). RAVI bypasses all of that complexity. Two SMAs. One subtraction. One division. One absolute value.
+
+The parameter choice is deliberate. The long SMA of 65 bars corresponds to approximately 13 trading weeks (one quarter), capturing the medium-term sentiment of market participants. The short SMA of 7 bars is roughly 10% of the long period, providing a responsive measure of current price relative to the quarterly trend. The 10:1 ratio between long and short periods ensures sufficient separation for meaningful divergence without the noise amplification that a 3:1 or 5:1 ratio would introduce.
+
+The 3% threshold was Chande's empirical choice for equities. He noted that this value varies by market and timeframe. For forex pairs with lower percentage moves, thresholds of 0.1% to 0.3% are common. For volatile commodities, 5% or higher may be appropriate. The threshold is a parameter, not a constant.
+
+Compared to its competitors in the trend-strength space: ADX is more nuanced (it captures direction via +DI/-DI) but computationally heavier and slower to respond. Kaufman's Efficiency Ratio (ER) measures net displacement versus total path length but operates on raw price changes without averaging. Choppiness Index (CHOP) uses ATR-to-range scaling on a logarithmic axis. PFE measures fractal efficiency in price-time space. RAVI trades sophistication for speed and clarity. It cannot tell you the direction of the trend (the absolute value discards sign), but it tells you whether a trend exists with minimal computational overhead and minimal warmup.
+
+Most implementations across platforms (MetaTrader, NinjaTrader, Wealth-Lab, NanoTrader, Sierra Chart) follow Chande's original SMA-based formula. Some variants offer EMA as an alternative smoothing method, and a few preserve the sign of the difference (positive for price above long MA, negative for below) rather than taking the absolute value. This implementation follows Chande's original: SMA-only, absolute value, outputting a non-negative percentage.
+
+## Architecture and Physics
+
+### 1. Short-Period SMA
+
+The fast simple moving average computes the arithmetic mean of the most recent $N_s$ close values:
+
+$$
+\text{SMA}_s(t) = \frac{1}{N_s} \sum_{i=0}^{N_s - 1} C_{t-i}
+$$
+
+In streaming mode, a circular buffer of size $N_s$ maintains a running sum. On each new bar, the oldest value is subtracted and the current close is added, achieving O(1) per update.
+
+### 2. Long-Period SMA
+
+The slow simple moving average operates identically over a larger window $N_l$:
+
+$$
+\text{SMA}_l(t) = \frac{1}{N_l} \sum_{i=0}^{N_l - 1} C_{t-i}
+$$
+
+A separate circular buffer of size $N_l$ with its own running sum provides the O(1) update.
+
+### 3. Absolute Percentage Difference
+
+The raw divergence between averages is normalized by the long SMA and scaled to percentage:
+
+$$
+\text{RAVI}_{\text{raw}}(t) = \frac{\text{SMA}_s(t) - \text{SMA}_l(t)}{\text{SMA}_l(t)} \times 100
+$$
+
+This normalization makes RAVI price-scale invariant. A $5 stock and a $500 stock with the same percentage structure produce the same RAVI values.
+
+### 4. Absolute Value
+
+Chande's original definition discards direction:
+
+$$
+\text{RAVI}(t) = \left| \text{RAVI}_{\text{raw}}(t) \right|
+$$
+
+The output is always non-negative. Values represent the magnitude of divergence between short-term and long-term price consensus, regardless of whether the short MA is above or below the long MA.
+
+### 5. Threshold Classification
+
+RAVI's primary use is binary classification:
+
+$$
+\text{Regime} = \begin{cases}
+\text{Trending} & \text{if } \text{RAVI}(t) > \theta \\
+\text{Ranging} & \text{if } \text{RAVI}(t) \leq \theta
+\end{cases}
+$$
+
+where $\theta$ is the threshold (default 3.0%). The threshold line is plotted as a reference but is not part of the indicator's computation. Different markets and timeframes require different thresholds. Chande's 3% was calibrated for daily US equity data.
+
+### 6. Complexity
+
+- **Time:** O(1) per bar (two running-sum updates + one division + one absolute value). No loops, no square roots, no exponentials.
+- **Space:** O($N_s + N_l$) for the two circular buffers. With defaults: $7 + 65 = 72$ doubles.
+- **Warmup:** $N_l$ bars (the long SMA must fill completely). With default $N_l = 65$, the first valid RAVI appears on bar 65.
+- **State footprint:** Two circular buffers ($N_s + N_l$ doubles), two running sums, two fill counters.
+
+## Mathematical Foundation
+
+### RAVI Derivation
+
+Given a price series $\{C_0, C_1, \ldots, C_t\}$, the RAVI at bar $t$ with short period $N_s$ and long period $N_l$ is:
+
+$$
+\text{RAVI}(t) = \left| \frac{\text{SMA}(C, N_s, t) - \text{SMA}(C, N_l, t)}{\text{SMA}(C, N_l, t)} \right| \times 100
+$$
+
+Expanding the SMA definitions:
+
+$$
+\text{RAVI}(t) = \left| \frac{\frac{1}{N_s}\sum_{i=0}^{N_s-1} C_{t-i} - \frac{1}{N_l}\sum_{i=0}^{N_l-1} C_{t-i}}{\frac{1}{N_l}\sum_{i=0}^{N_l-1} C_{t-i}} \right| \times 100
+$$
+
+Simplifying:
+
+$$
+\text{RAVI}(t) = \left| \frac{N_l \sum_{i=0}^{N_s-1} C_{t-i} - N_s \sum_{i=0}^{N_l-1} C_{t-i}}{N_s \sum_{i=0}^{N_l-1} C_{t-i}} \right| \times 100
+$$
+
+### Bounds Analysis
+
+**Lower bound:** When $\text{SMA}_s = \text{SMA}_l$ (price is flat or symmetrically oscillating), RAVI = 0.
+
+**Upper bound:** RAVI has no theoretical upper bound. If the short SMA diverges sufficiently from the long SMA (e.g., a parabolic move), RAVI grows without limit. In practice, for typical equity data, RAVI values above 10% are rare and above 20% are extreme.
+
+**Typical range:** For daily equity data with default parameters, RAVI typically oscillates between 0% and 8%. Strongly trending markets (sustained directional moves over several weeks) produce values of 5-10%. Choppy sideways markets produce values below 2%.
+
+### Relationship to MACD
+
+RAVI is structurally related to the Percentage Price Oscillator (PPO), which computes:
+
+$$
+\text{PPO}(t) = \frac{\text{EMA}_s(t) - \text{EMA}_l(t)}{\text{EMA}_l(t)} \times 100
+$$
+
+RAVI uses SMA instead of EMA, and takes the absolute value. PPO preserves sign and direction. If you replaced the SMAs with EMAs and dropped the absolute value, RAVI would become PPO.
+
+### Relationship to VIDYA
+
+VIDYA uses a ratio of short-term to long-term standard deviations to adapt its smoothing constant. RAVI uses a ratio of short-term to long-term price levels (via SMA) to measure trend presence. Both indicators reflect Chande's philosophy of comparing short-horizon behavior against long-horizon behavior, but they answer different questions: VIDYA asks "how volatile is price right now?" while RAVI asks "how far has price moved from its long-term average?"
+
+### Parameter Mapping
+
+| Symbol | Parameter | Default | Constraint |
+|--------|-----------|---------|------------|
+| $N_s$ | shortPeriod | 7 | $N_s \geq 1$ |
+| $N_l$ | longPeriod | 65 | $N_l > N_s$ |
+| $\theta$ | threshold | 3.0% | $\theta \geq 0$ (display only) |
+
+| Short | Long | Ratio | Warmup | Sensitivity | Best For |
+|-------|------|-------|--------|-------------|----------|
+| 7 | 65 | 1:9.3 | 65 bars | Standard | Daily equity, Chande's original |
+| 5 | 50 | 1:10 | 50 bars | Higher | Faster response, more noise |
+| 10 | 100 | 1:10 | 100 bars | Lower | Weekly charts, long-term trends |
+| 3 | 30 | 1:10 | 30 bars | High | Intraday, scalping |
+
+Chande's rule of thumb: long period = quarterly equivalent for your timeframe; short period = 10% of long period, rounded to nearest integer.
+
+## Performance Profile
+
+### Operation Count (Streaming Mode, Scalar)
+
+Per-bar operations with circular buffers for both SMAs:
+
+| Operation | Count | Cost (cycles) | Subtotal |
+|:----------|:-----:|:-------------:|:--------:|
+| SUB (remove oldest from running sum) | 2 | 1 | 2 |
+| ADD (add current to running sum) | 2 | 1 | 2 |
+| DIV (running sum / period, x2) | 2 | 15 | 30 |
+| SUB (SMA_short - SMA_long) | 1 | 1 | 1 |
+| DIV (normalize by SMA_long) | 1 | 15 | 15 |
+| MUL (scale by 100) | 1 | 3 | 3 |
+| ABS (absolute value) | 1 | 1 | 1 |
+| **Total** | **10** | | **~54 cycles** |
+
+RAVI is one of the cheapest indicators in the dynamics category. For comparison, ADX requires approximately 200+ cycles per bar, and PFE requires ~191 cycles per bar (for period=10). RAVI's 54 cycles makes it roughly 4x cheaper than either.
+
+### Batch Mode (SIMD Analysis)
+
+| Operation | Vectorizable? | Notes |
+|:----------|:-------------:|:------|
+| Running sum update (short) | Yes | Prefix sum, then subtract lagged prefix sum |
+| Running sum update (long) | Yes | Same pattern, different lag |
+| Division (SMA computation) | Yes | VDIVPD, 4 doubles per op |
+| Subtraction (SMA_s - SMA_l) | Yes | VSUBPD |
+| Division (normalization) | Yes | VDIVPD |
+| Absolute value | Yes | VANDPD with sign-bit mask |
+| Multiply by 100 | Yes | VMULPD |
+
+The entire `Calculate(Span)` pipeline is fully vectorizable. Both SMA computations can use the prefix-sum trick: compute a cumulative sum of the input, then $\text{SMA}(t) = (\text{prefix}[t] - \text{prefix}[t - N]) / N$. This transforms the two O($N$) naive loops into O(1) per element with a single O($n$) prefix-sum pass.
+
+With AVX2 processing 4 doubles per instruction, the batch path achieves near-4x speedup over scalar for large arrays. No sequential dependencies exist in the final RAVI computation once both SMA arrays are materialized.
+
+### Quality Metrics
+
+| Metric | Score | Notes |
+|:-------|:-----:|:------|
+| **Accuracy** | 10/10 | Exact arithmetic, no approximations, no recursive state |
+| **Timeliness** | 5/10 | Long SMA ($N_l = 65$) introduces substantial lag; trend detection is delayed |
+| **Smoothness** | 8/10 | SMA inherently smooth; no jitter from recursive feedback |
+| **Noise Rejection** | 6/10 | SMA provides linear filtering but no adaptive bandwidth |
+| **Interpretability** | 9/10 | Single percentage value with clear threshold; binary trending/ranging classification |
+
+## Validation
+
+| Library | Status | Notes |
+|:--------|:------:|:------|
+| **TA-Lib** | N/A | Not implemented in TA-Lib |
+| **Skender** | N/A | Not available in Skender.Stock.Indicators |
+| **Tulip** | N/A | Not implemented in Tulip Indicators |
+| **OoplesFinance** | Pending | May be available; check `RangeActionVerificationIndex` |
+| **Wealth-Lab** | Reference | WL5 Wiki documents RAVI with SMA/EMA option + absolute/signed option |
+| **MetaTrader** | Reference | MQL5 Code Base implementations available; SmoothAlgorithms.mqh version |
+| **NanoTrader** | Reference | Built-in RAVI with configurable threshold |
+| **Sierra Chart** | Caution | Sierra Chart's "RAVI" is a different indicator (Rapid Adaptive Variance) using VIDYA |
+
+Key validation points:
+
+- For a constant price series (all closes identical), RAVI must equal exactly 0
+- For a monotonically increasing series with constant increment, RAVI must be positive and stable after warmup
+- RAVI must always be non-negative (absolute value constraint)
+- With $N_s = N_l$, RAVI must equal 0 for all bars (same SMA)
+- Warmup: first $N_l - 1$ bars produce NaN
+- Division guard: if SMA_long = 0, output NaN (avoid division by zero)
+- RAVI is symmetric: a market that rises X% and then falls X% back to start produces approximately equal RAVI values during both phases
+
+## Common Pitfalls
+
+1. **Confusing Chande's RAVI with Sierra Chart's RAVI.** Sierra Chart documents a "Rapid Adaptive Variance Indicator" that uses VIDYA internally. It shares the RAVI acronym but is a completely different indicator with different inputs, computation, and interpretation. Using Sierra Chart's formula when Chande's is intended (or vice versa) produces entirely unrelated output. Always verify which RAVI definition your platform implements.
+
+2. **Using a fixed 3% threshold across all markets.** Chande's 3% threshold was calibrated for daily US equity data. Forex pairs with 0.5% daily ranges need thresholds of 0.1-0.3%. Crypto assets with 5-10% daily ranges may need thresholds of 8-15%. A fixed threshold misclassifies regime in roughly 30-50% of markets.
+
+3. **Preserving sign instead of taking absolute value.** Some implementations skip the absolute value, producing a signed indicator where positive means "short MA above long MA" and negative means "short MA below long MA." This changes RAVI from a trend-strength indicator into a trend-direction indicator. Both interpretations have value, but mixing them in code that expects the other convention produces incorrect regime classification.
+
+4. **Using EMA instead of SMA.** Wealth-Lab and some other platforms offer EMA as an alternative. EMA responds faster but introduces exponential decay, changing the effective lookback characteristics. The long EMA never fully forgets old data (IIR behavior), while the long SMA has a hard cutoff at $N_l$ bars (FIR behavior). For RAVI's threshold-based classification, this difference shifts the optimal threshold by 10-20% and changes the warmup characteristics.
+
+5. **Setting short and long periods too close together.** Chande's 10:1 ratio (7:65) provides clear separation between timeframes. A 2:1 ratio (e.g., 30:60) means both SMAs respond to similar frequencies, and RAVI stays near zero even during trends. The indicator loses discriminating power. Maintain at least a 5:1 ratio between long and short periods.
+
+6. **Expecting RAVI to indicate trend direction.** RAVI's absolute value explicitly discards direction. A strong uptrend and a strong downtrend produce the same RAVI value. If direction matters, use RAVI in conjunction with a directional indicator (the sign of the short-long SMA difference, a simple price-above-MA test, or MACD).
+
+7. **Ignoring the warmup period.** RAVI requires $N_l$ bars (65 by default) before producing a valid reading. During warmup, the long SMA is undefined. Some implementations return 0 during warmup, which falsely signals a ranging market. Return NaN until the long SMA buffer is full.
+
+## References
+
+- Chande, Tushar S. *Beyond Technical Analysis: How to Develop and Implement a Winning Trading System*. 2nd Edition. John Wiley & Sons, 2001. ISBN: 0471415677. Chapter on RAVI, pp. 66-70.
+- Chande, Tushar S. "Adapting Moving Averages to Market Volatility." *Stocks & Commodities*, V10:3, 1992. pp. 108-114. (VIDYA introduction; RAVI is the companion trend classifier.)
+- Chande, Tushar S., and Kroll, Stanley. *The New Technical Trader: Boost Your Profit by Plugging into the Latest Indicators*. John Wiley & Sons, 1994. ISBN: 0471597805.
+- Wilder, J. Welles. *New Concepts in Technical Trading Systems*. Trend Research, 1978. (ADX reference for comparison.)
+- PineScript reference: `ravi.pine` in indicator directory.

lib/dynamics/ravi/ravi.pine

@@ -0,0 +1,79 @@
+// The MIT License (MIT)
+// © mihakralj
+//@version=6
+indicator("RAVI: Chande Range Action Verification Index", "RAVI", overlay=false)
+
+//@function Calculates Range Action Verification Index using short/long SMA divergence
+//@param shortPeriod Lookback period for fast SMA (default: 7, ~10% of longPeriod)
+//@param longPeriod Lookback period for slow SMA (default: 65, ~13 weeks daily)
+//@returns RAVI value as absolute percentage divergence between short and long SMAs
+//@references Tushar Chande, "Beyond Technical Analysis", Wiley, 2nd ed. (2001), pp. 66-70
+//@optimized O(1) per bar via circular buffer running sums for both SMAs
+ravi(simple int shortPeriod, simple int longPeriod) =>
+    if shortPeriod <= 0
+        runtime.error("Short period must be greater than 0")
+    if longPeriod <= 0
+        runtime.error("Long period must be greater than 0")
+    if shortPeriod >= longPeriod
+        runtime.error("Short period must be less than long period")
+
+    // Circular buffer for short SMA (O(1) running sum)
+    var array<float> shortBuf = array.new_float(shortPeriod, na)
+    var int shortHead = 0
+    var int shortFilled = 0
+    var float shortSum = 0.0
+
+    // Circular buffer for long SMA (O(1) running sum)
+    var array<float> longBuf = array.new_float(longPeriod, na)
+    var int longHead = 0
+    var int longFilled = 0
+    var float longSum = 0.0
+
+    // Update short SMA buffer
+    float oldShort = array.get(shortBuf, shortHead)
+    if not na(oldShort)
+        shortSum -= oldShort
+    shortSum += close
+    array.set(shortBuf, shortHead, close)
+    shortFilled := math.min(shortFilled + 1, shortPeriod)
+    shortHead := (shortHead + 1) % shortPeriod
+
+    // Update long SMA buffer
+    float oldLong = array.get(longBuf, longHead)
+    if not na(oldLong)
+        longSum -= oldLong
+    longSum += close
+    array.set(longBuf, longHead, close)
+    longFilled := math.min(longFilled + 1, longPeriod)
+    longHead := (longHead + 1) % longPeriod
+
+    float result = na
+
+    if shortFilled >= shortPeriod and longFilled >= longPeriod
+        // Step 1: Compute short-period SMA
+        float smaShort = shortSum / shortPeriod
+
+        // Step 2: Compute long-period SMA
+        float smaLong = longSum / longPeriod
+
+        // Step 3: RAVI = |SMA(short) - SMA(long)| / SMA(long) * 100
+        // Guard against division by zero (long SMA at zero)
+        if math.abs(smaLong) > 1e-10
+            result := math.abs(smaShort - smaLong) / math.abs(smaLong) * 100.0
+
+    result
+
+// ---------- Main loop ----------
+
+// Inputs
+i_short = input.int(7, "Short Period", minval=1, maxval=100, tooltip="Fast SMA period (~10% of long period; Chande default: 7)")
+i_long = input.int(65, "Long Period", minval=2, maxval=500, tooltip="Slow SMA period (~13 weeks daily; Chande default: 65)")
+i_threshold = input.float(3.0, "Threshold", minval=0.0, maxval=20.0, step=0.5, tooltip="Trend/range classification level (Chande default: 3%)")
+
+// Calculation
+ravi_value = ravi(i_short, i_long)
+
+// Plot
+plot(ravi_value, "RAVI", color=color.yellow, linewidth=2)
+hline(i_threshold, "Threshold", color=color.new(color.red, 50), linestyle=hline.style_dashed)
+hline(0, "Zero Line", color=color.new(color.gray, 70), linestyle=hline.style_dotted)