Add Standard Deviation Channel (SDCHANNEL) implementation and documentation

- Implemented Sdchannel class for calculating standard deviation channels based on linear regression. - Added detailed documentation for SDCHANNEL, including overview, calculation methods, and interpretation. - Updated project files to include new numerics library components in Channels and Volatility projects.
2026-08-20 19:48:05 +00:00 · 2026-01-21 14:41:31 -05:00
parent b2c1787782
commit 3eae9a76fe
71 changed files with 15716 additions and 772 deletions
@@ -0,0 +1,258 @@
+using TradingPlatform.BusinessLayer;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class MaenvIndicatorTests
+{
+    [Fact]
+    public void Constructor_SetsDefaults()
+    {
+        var ind = new MaenvIndicator();
+
+        Assert.Equal(20, ind.Period);
+        Assert.Equal(1.0, ind.Percentage);
+        Assert.Equal(MaenvType.EMA, ind.MaType);
+        Assert.Equal(PriceType.Close, ind.SourceType);
+        Assert.True(ind.ShowColdValues);
+        Assert.Equal("Maenv - Moving Average Envelope", ind.Name);
+        Assert.False(ind.SeparateWindow);
+        Assert.True(ind.OnBackGround);
+    }
+
+    [Fact]
+    public void MinHistoryDepths_EqualsPeriod()
+    {
+        var ind = new MaenvIndicator { Period = 15 };
+        Assert.Equal(15, ind.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ShortName_ReflectsParameters()
+    {
+        var ind = new MaenvIndicator { Period = 12, Percentage = 2.5, MaType = MaenvType.SMA };
+        Assert.Contains("12", ind.ShortName, StringComparison.Ordinal);
+        Assert.Contains("2.5", ind.ShortName, StringComparison.Ordinal);
+        Assert.Contains("SMA", ind.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Initialize_AddsThreeLineSeries()
+    {
+        var ind = new MaenvIndicator { Period = 14, Percentage = 2.0 };
+        ind.Initialize();
+
+        Assert.Equal(3, ind.LinesSeries.Count);
+        Assert.Equal("Middle", ind.LinesSeries[0].Name);
+        Assert.Equal("Upper", ind.LinesSeries[1].Name);
+        Assert.Equal("Lower", ind.LinesSeries[2].Name);
+    }
+
+    [Fact]
+    public void ProcessUpdate_Historical_ComputesValues()
+    {
+        var ind = new MaenvIndicator { Period = 3, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 102);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        Assert.Equal(1, ind.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(0)));
+        Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(0)));
+        Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(0)));
+    }
+
+    [Fact]
+    public void ProcessUpdate_NewBar_Appends()
+    {
+        var ind = new MaenvIndicator { Period = 3, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 102);
+        ind.HistoricalData.AddBar(now.AddMinutes(1), 102, 112, 92, 104);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, ind.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void ProcessUpdate_NewTick_DoesNotThrow()
+    {
+        var ind = new MaenvIndicator { Period = 5, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+
+        Assert.Equal(2, ind.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void MultipleUpdates_ProducesFiniteSeries()
+    {
+        var ind = new MaenvIndicator { Period = 5, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        Assert.Equal(20, ind.LinesSeries[0].Count);
+        Assert.Equal(20, ind.LinesSeries[1].Count);
+        Assert.Equal(20, ind.LinesSeries[2].Count);
+
+        for (int i = 0; i < 20; i++)
+        {
+            Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(i)));
+            Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(i)));
+            Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(i)));
+        }
+    }
+
+    [Fact]
+    public void Bands_Order_Correct()
+    {
+        var ind = new MaenvIndicator { Period = 5, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 100, 1000);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        Assert.True(upper > middle, $"Upper ({upper}) should be > Middle ({middle})");
+        Assert.True(lower < middle, $"Lower ({lower}) should be < Middle ({middle})");
+    }
+
+    [Fact]
+    public void FirstBar_BandsAtPercentage()
+    {
+        var ind = new MaenvIndicator { Period = 10, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 100);
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        // First bar: middle = close, bands at ±2%
+        Assert.Equal(100.0, middle, 1e-10);
+        Assert.Equal(102.0, upper, 1e-10);
+        Assert.Equal(98.0, lower, 1e-10);
+    }
+
+    [Fact]
+    public void Percentage_AffectsBandWidth()
+    {
+        var ind1 = new MaenvIndicator { Period = 10, Percentage = 1.0 };
+        var ind2 = new MaenvIndicator { Period = 10, Percentage = 2.0 };
+        ind1.Initialize();
+        ind2.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            ind1.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 100);
+            ind2.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 100);
+            ind1.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+            ind2.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double width1 = ind1.LinesSeries[1].GetValue(0) - ind1.LinesSeries[2].GetValue(0);
+        double width2 = ind2.LinesSeries[1].GetValue(0) - ind2.LinesSeries[2].GetValue(0);
+
+        Assert.Equal(width2, width1 * 2, 1e-9);
+    }
+
+    [Fact]
+    public void Bands_Symmetric_AroundMiddle()
+    {
+        var ind = new MaenvIndicator { Period = 10, Percentage = 3.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 100 + i);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        double upperDist = upper - middle;
+        double lowerDist = middle - lower;
+
+        Assert.Equal(upperDist, lowerDist, 1e-10);
+    }
+
+    [Fact]
+    public void AllMaTypes_ProduceFiniteResults()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new MaenvIndicator { Period = 10, Percentage = 2.0, MaType = maType };
+            ind.Initialize();
+
+            var now = DateTime.UtcNow;
+            for (int i = 0; i < 20; i++)
+            {
+                ind.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 100 + i);
+                ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+            }
+
+            for (int i = 0; i < 20; i++)
+            {
+                Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(i)), $"{maType} Middle finite at {i}");
+                Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(i)), $"{maType} Upper finite at {i}");
+                Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(i)), $"{maType} Lower finite at {i}");
+            }
+        }
+    }
+
+    [Fact]
+    public void DifferentPriceTypes_Work()
+    {
+        var indClose = new MaenvIndicator { Period = 5, Percentage = 1.0, SourceType = PriceType.Close };
+        var indHigh = new MaenvIndicator { Period = 5, Percentage = 1.0, SourceType = PriceType.High };
+        indClose.Initialize();
+        indHigh.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indClose.HistoricalData.AddBar(now.AddMinutes(i), 100, 120, 80, 100);
+            indHigh.HistoricalData.AddBar(now.AddMinutes(i), 100, 120, 80, 100);
+            indClose.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+            indHigh.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        // High should be higher than Close for the same percentage
+        double closeMiddle = indClose.LinesSeries[0].GetValue(0);
+        double highMiddle = indHigh.LinesSeries[0].GetValue(0);
+
+        Assert.True(highMiddle > closeMiddle, "High price type should produce higher middle than Close");
+    }
+}
@@ -0,0 +1,74 @@
+using System.Drawing;
+using TradingPlatform.BusinessLayer;
+using static QuanTAlib.IndicatorExtensions;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// Maenv: Moving Average Envelope - Quantower Indicator Adapter
+/// A percentage-based envelope using a selectable moving average as the middle line.
+/// Middle = MA(source, period) - SMA, EMA, or WMA
+/// Upper = Middle + (Middle × percentage / 100)
+/// Lower = Middle - (Middle × percentage / 100)
+/// </summary>
+public sealed class MaenvIndicator : Indicator, IWatchlistIndicator
+{
+    [InputParameter("Period", sortIndex: 10, minimum: 1, maximum: 500, increment: 1, decimalPlaces: 0)]
+    public int Period { get; set; } = 20;
+
+    [InputParameter("Percentage", sortIndex: 20, minimum: 0.01, maximum: 100.0, increment: 0.1, decimalPlaces: 2)]
+    public double Percentage { get; set; } = 1.0;
+
+    [InputParameter("MA Type", sortIndex: 30)]
+    public MaenvType MaType { get; set; } = MaenvType.EMA;
+
+    [InputParameter("Price Type", sortIndex: 40)]
+    public PriceType SourceType { get; set; } = PriceType.Close;
+
+    [InputParameter("Show Cold Values", sortIndex: 100)]
+    public bool ShowColdValues { get; set; } = true;
+
+    private Maenv? _indicator;
+
+    public int MinHistoryDepths => Period;
+    public override string ShortName => $"Maenv({Period},{Percentage},{MaType})";
+
+    public MaenvIndicator()
+    {
+        Name = "Maenv - Moving Average Envelope";
+        Description = "Percentage-based envelope using selectable MA (SMA/EMA/WMA)";
+        SeparateWindow = false;
+        OnBackGround = true;
+    }
+
+    protected override void OnInit()
+    {
+        _indicator = new Maenv(Period, Percentage, MaType);
+
+        AddLineSeries(new LineSeries("Middle", Color.DodgerBlue, 2, LineStyle.Solid));
+        AddLineSeries(new LineSeries("Upper", Color.FromArgb(255, 180, 180), 1, LineStyle.Dash));
+        AddLineSeries(new LineSeries("Lower", Color.FromArgb(180, 180, 255), 1, LineStyle.Dash));
+    }
+
+    protected override void OnUpdate(UpdateArgs args)
+    {
+        if (_indicator is null)
+            return;
+
+        var item = HistoricalData[0, SeekOriginHistory.End];
+        bool isNew = args.IsNewBar();
+
+        TValue input = new(
+            time: item.TimeLeft,
+            value: item[SourceType]
+        );
+
+        _indicator.Update(input, isNew);
+
+        bool isHot = _indicator.IsHot;
+
+        LinesSeries[0].SetValue(_indicator.Last.Value, isHot, ShowColdValues);
+        LinesSeries[1].SetValue(_indicator.Upper.Value, isHot, ShowColdValues);
+        LinesSeries[2].SetValue(_indicator.Lower.Value, isHot, ShowColdValues);
+    }
+}
@@ -0,0 +1,388 @@
+using System;
+using QuanTAlib;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class MaenvTests
+{
+    [Fact]
+    public void Maenv_Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(-5));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(10, 0.0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(10, -1.0));
+
+        var m = new Maenv(10, 2.0);
+        Assert.Equal(10, m.WarmupPeriod);
+        Assert.Contains("Maenv", m.Name, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Maenv_InitialState_Defaults()
+    {
+        var m = new Maenv(5);
+
+        Assert.Equal(0, m.Last.Value);
+        Assert.Equal(0, m.Upper.Value);
+        Assert.Equal(0, m.Lower.Value);
+        Assert.False(m.IsHot);
+    }
+
+    [Fact]
+    public void Maenv_FirstValue_AllBandsCorrect()
+    {
+        var m = new Maenv(10, 1.0, MaenvType.EMA);
+
+        var result = m.Update(new TValue(DateTime.UtcNow, 100));
+
+        // First value: MA = input, bands at ±1%
+        Assert.Equal(100.0, result.Value, 1e-10);
+        Assert.Equal(101.0, m.Upper.Value, 1e-10);
+        Assert.Equal(99.0, m.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Maenv_BandWidth_ProportionalToPercentage()
+    {
+        var m1 = new Maenv(10, 1.0);
+        var m2 = new Maenv(10, 2.0);
+        var m3 = new Maenv(10, 5.0);
+
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            var tv = new TValue(bar.Time, bar.Close);
+            m1.Update(tv);
+            m2.Update(tv);
+            m3.Update(tv);
+        }
+
+        double width1 = m1.Upper.Value - m1.Lower.Value;
+        double width2 = m2.Upper.Value - m2.Lower.Value;
+        double width3 = m3.Upper.Value - m3.Lower.Value;
+
+        // Width should scale with percentage (width = 2 * middle * pct / 100)
+        Assert.Equal(width2, width1 * 2, 1e-9);
+        Assert.Equal(width3, width1 * 5, 1e-9);
+    }
+
+    [Fact]
+    public void Maenv_BandOrder_Correct()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var m = new Maenv(10, 2.0, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+            for (int i = 0; i < 50; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                m.Update(new TValue(bar.Time, bar.Close));
+
+                // Upper > Middle > Lower (for positive prices)
+                Assert.True(m.Upper.Value > m.Last.Value, $"{maType}: Upper > Middle at bar {i}");
+                Assert.True(m.Lower.Value < m.Last.Value, $"{maType}: Lower < Middle at bar {i}");
+            }
+        }
+    }
+
+    [Fact]
+    public void Maenv_BandSymmetry_PercentageBased()
+    {
+        var m = new Maenv(10, 3.0, MaenvType.EMA);
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            m.Update(new TValue(bar.Time, bar.Close));
+
+            // Bands should be symmetric around middle
+            double upperDist = m.Upper.Value - m.Last.Value;
+            double lowerDist = m.Last.Value - m.Lower.Value;
+            Assert.Equal(upperDist, lowerDist, 1e-10);
+
+            // Distance should be exactly percentage of middle
+            double expectedDist = m.Last.Value * 3.0 / 100.0;
+            Assert.Equal(expectedDist, upperDist, 1e-10);
+        }
+    }
+
+    [Fact]
+    public void Maenv_SMA_CorrectCalculation()
+    {
+        var m = new Maenv(3, 1.0, MaenvType.SMA);
+
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        Assert.Equal(100.0, m.Last.Value, 1e-10); // SMA(100) = 100
+
+        m.Update(new TValue(DateTime.UtcNow, 110));
+        Assert.Equal(105.0, m.Last.Value, 1e-10); // SMA(100,110) = 105
+
+        m.Update(new TValue(DateTime.UtcNow, 120));
+        Assert.Equal(110.0, m.Last.Value, 1e-10); // SMA(100,110,120) = 110
+
+        m.Update(new TValue(DateTime.UtcNow, 130));
+        Assert.Equal(120.0, m.Last.Value, 1e-10); // SMA(110,120,130) = 120
+    }
+
+    [Fact]
+    public void Maenv_EMA_WarmupCompensation()
+    {
+        var m = new Maenv(20, 1.0, MaenvType.EMA);
+
+        // Feed constant values
+        for (int i = 0; i < 100; i++)
+        {
+            m.Update(new TValue(DateTime.UtcNow, 100));
+        }
+
+        // EMA should converge to 100 due to warmup compensation
+        Assert.InRange(m.Last.Value, 99.9, 100.1);
+    }
+
+    [Fact]
+    public void Maenv_WMA_WeightedCorrectly()
+    {
+        var m = new Maenv(3, 1.0, MaenvType.WMA);
+
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        Assert.Equal(100.0, m.Last.Value, 1e-10);
+
+        // Second value: weights (3,2) for values (110,100)
+        // norm = 3*3 + 2*3 = 15, but for partial fill: w=(3-0)*3=9 for newest, w=(3-1)*3=6 for older
+        // Actual: first bar w=9, second bar: newest w=9, oldest w=6; sum=110*9+100*6=990+600=1590; norm=15
+        // WMA = 1590/15 = 106
+        m.Update(new TValue(DateTime.UtcNow, 110));
+        double expected2 = (110 * 9 + 100 * 6) / 15.0;
+        Assert.Equal(expected2, m.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Maenv_IsHot_TurnsTrueAfterWarmup()
+    {
+        var m = new Maenv(5, 1.0);
+
+        for (int i = 0; i < 4; i++)
+        {
+            m.Update(new TValue(DateTime.UtcNow, 100 + i));
+            Assert.False(m.IsHot);
+        }
+
+        m.Update(new TValue(DateTime.UtcNow, 200));
+        Assert.True(m.IsHot);
+    }
+
+    [Fact]
+    public void Maenv_IsNewFalse_RebuildsState()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var m = new Maenv(10, 2.0, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 7);
+
+            TValue remembered = default;
+            for (int i = 0; i < 30; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                remembered = new TValue(bar.Time, bar.Close);
+                m.Update(remembered, isNew: true);
+            }
+
+            double mid = m.Last.Value;
+            double up = m.Upper.Value;
+            double lo = m.Lower.Value;
+
+            // Apply corrections
+            for (int i = 0; i < 5; i++)
+            {
+                var bar = gbm.Next(isNew: false);
+                m.Update(new TValue(bar.Time, bar.Close), isNew: false);
+            }
+
+            // Restore with remembered value
+            m.Update(remembered, isNew: false);
+
+            Assert.Equal(mid, m.Last.Value, 1e-6);
+            Assert.Equal(up, m.Upper.Value, 1e-6);
+            Assert.Equal(lo, m.Lower.Value, 1e-6);
+        }
+    }
+
+    [Fact]
+    public void Maenv_NaN_UsesLastValid()
+    {
+        var m = new Maenv(10, 2.0);
+
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        m.Update(new TValue(DateTime.UtcNow, 105));
+
+        var result = m.Update(new TValue(DateTime.UtcNow, double.NaN));
+        Assert.True(double.IsFinite(result.Value));
+        Assert.True(double.IsFinite(m.Upper.Value));
+        Assert.True(double.IsFinite(m.Lower.Value));
+
+        var result2 = m.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity));
+        Assert.True(double.IsFinite(result2.Value));
+    }
+
+    [Fact]
+    public void Maenv_Reset_Clears()
+    {
+        var m = new Maenv(10, 2.0);
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        m.Update(new TValue(DateTime.UtcNow, 110));
+        m.Update(new TValue(DateTime.UtcNow, 120));
+
+        m.Reset();
+
+        Assert.Equal(0, m.Last.Value);
+        Assert.Equal(0, m.Upper.Value);
+        Assert.Equal(0, m.Lower.Value);
+        Assert.False(m.IsHot);
+
+        m.Update(new TValue(DateTime.UtcNow, 50));
+        Assert.NotEqual(0, m.Last.Value);
+    }
+
+    [Fact]
+    public void Maenv_BatchVsStreaming_Match()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var mStream = new Maenv(20, 1.5, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.02, sigma: 0.15, seed: 42);
+            var series = new TSeries();
+
+            for (int i = 0; i < 200; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                series.Add(new TValue(bar.Time, bar.Close));
+                mStream.Update(series.Last, isNew: true);
+            }
+
+            double expectedMid = mStream.Last.Value;
+            double expectedUp = mStream.Upper.Value;
+            double expectedLo = mStream.Lower.Value;
+
+            var (midBatch, upBatch, loBatch) = Maenv.Batch(series, 20, 1.5, maType);
+
+            Assert.Equal(expectedMid, midBatch.Last.Value, 1e-9);
+            Assert.Equal(expectedUp, upBatch.Last.Value, 1e-9);
+            Assert.Equal(expectedLo, loBatch.Last.Value, 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Maenv_SpanBatch_Validates()
+    {
+        double[] source = [100, 105, 110];
+        double[] middle = new double[3];
+        double[] upper = new double[3];
+        double[] lower = new double[3];
+        double[] smallOut = new double[1];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), -1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 10, 0.0));
+        Assert.Throws<ArgumentException>(() => Maenv.Batch(source.AsSpan(), smallOut.AsSpan(), upper.AsSpan(), lower.AsSpan(), 2));
+    }
+
+    [Fact]
+    public void Maenv_SpanBatch_ComputesCorrectly()
+    {
+        double[] source = [100, 105, 110, 107, 115];
+        double[] middle = new double[5];
+        double[] upper = new double[5];
+        double[] lower = new double[5];
+
+        Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 3, 2.0, MaenvType.EMA);
+
+        // First value: MA = 100, bands at ±2%
+        Assert.Equal(100.0, middle[0], 1e-10);
+        Assert.Equal(102.0, upper[0], 1e-10);
+        Assert.Equal(98.0, lower[0], 1e-10);
+
+        // All bars: upper > middle > lower
+        for (int i = 0; i < 5; i++)
+        {
+            Assert.True(upper[i] > middle[i], $"Upper > Middle at {i}");
+            Assert.True(lower[i] < middle[i], $"Lower < Middle at {i}");
+        }
+    }
+
+    [Fact]
+    public void Maenv_Calculate_ReturnsIndicatorAndResults()
+    {
+        var series = new TSeries();
+        series.Add(new TValue(DateTime.UtcNow, 100));
+        series.Add(new TValue(DateTime.UtcNow, 105));
+        series.Add(new TValue(DateTime.UtcNow, 102));
+
+        var ((mid, up, lo), ind) = Maenv.Calculate(series, 2);
+
+        Assert.True(double.IsFinite(mid.Last.Value));
+        Assert.True(double.IsFinite(up.Last.Value));
+        Assert.True(double.IsFinite(lo.Last.Value));
+
+        // Continue streaming
+        ind.Update(new TValue(DateTime.UtcNow, 108));
+        Assert.True(double.IsFinite(ind.Last.Value));
+    }
+
+    [Fact]
+    public void Maenv_Event_Publishes()
+    {
+        var src = new TSeries();
+        var m = new Maenv(src, 2);
+        bool fired = false;
+        m.Pub += (object? sender, in TValueEventArgs args) => fired = true;
+
+        src.Add(new TValue(DateTime.UtcNow, 100));
+        Assert.True(fired);
+    }
+
+    [Fact]
+    public void Maenv_AllMaTypes_ProduceFiniteResults()
+    {
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var m = new Maenv(20, 2.5, maType);
+
+            for (int i = 0; i < 200; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                m.Update(new TValue(bar.Time, bar.Close));
+
+                Assert.True(double.IsFinite(m.Last.Value), $"{maType} Middle finite at {i}");
+                Assert.True(double.IsFinite(m.Upper.Value), $"{maType} Upper finite at {i}");
+                Assert.True(double.IsFinite(m.Lower.Value), $"{maType} Lower finite at {i}");
+            }
+        }
+    }
+
+    [Fact]
+    public void Maenv_LongSeriesStability()
+    {
+        var m = new Maenv(20, 2.0);
+        var gbm = new GBM(startPrice: 100, mu: 0.001, sigma: 0.02, seed: 123);
+
+        for (int i = 0; i < 10000; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            m.Update(new TValue(bar.Time, bar.Close));
+
+            Assert.True(double.IsFinite(m.Last.Value), $"Middle finite at {i}");
+            Assert.True(double.IsFinite(m.Upper.Value), $"Upper finite at {i}");
+            Assert.True(double.IsFinite(m.Lower.Value), $"Lower finite at {i}");
+            Assert.True(m.Upper.Value > m.Last.Value, $"Upper > Middle at {i}");
+            Assert.True(m.Lower.Value < m.Last.Value, $"Lower < Middle at {i}");
+        }
+    }
+}
@@ -0,0 +1,515 @@
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public sealed class MaenvValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public MaenvValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+        _testData = new ValidationTestData();
+    }
+
+    public void Dispose() => Dispose(true);
+
+    private void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+
+        if (disposing)
+        {
+            _testData?.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Validate_ManualCalculation_SMA()
+    {
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        // Simple values for manual verification
+        series.Add(new TValue(t0, 100));
+        series.Add(new TValue(t0.AddMinutes(1), 110));
+        series.Add(new TValue(t0.AddMinutes(2), 120));
+        series.Add(new TValue(t0.AddMinutes(3), 130));
+
+        var ind = new Maenv(3, 2.0, MaenvType.SMA);
+
+        // Bar 0: SMA(100) = 100, bands ±2%
+        ind.Update(series[0]);
+        Assert.Equal(100.0, ind.Last.Value, 1e-10);
+        Assert.Equal(102.0, ind.Upper.Value, 1e-10);
+        Assert.Equal(98.0, ind.Lower.Value, 1e-10);
+
+        // Bar 1: SMA(100,110) = 105, bands ±2%
+        ind.Update(series[1]);
+        Assert.Equal(105.0, ind.Last.Value, 1e-10);
+        Assert.Equal(107.1, ind.Upper.Value, 1e-10);
+        Assert.Equal(102.9, ind.Lower.Value, 1e-10);
+
+        // Bar 2: SMA(100,110,120) = 110, bands ±2%
+        ind.Update(series[2]);
+        Assert.Equal(110.0, ind.Last.Value, 1e-10);
+        Assert.Equal(112.2, ind.Upper.Value, 1e-10);
+        Assert.Equal(107.8, ind.Lower.Value, 1e-10);
+
+        // Bar 3: SMA(110,120,130) = 120, bands ±2%
+        ind.Update(series[3]);
+        Assert.Equal(120.0, ind.Last.Value, 1e-10);
+        Assert.Equal(122.4, ind.Upper.Value, 1e-10);
+        Assert.Equal(117.6, ind.Lower.Value, 1e-10);
+
+        _output.WriteLine("Maenv SMA manual calculation validated");
+    }
+
+    [Fact]
+    public void Validate_ManualCalculation_EMA_Convergence()
+    {
+        // Constant values should converge to that value due to warmup compensation
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        for (int i = 0; i < 100; i++)
+        {
+            series.Add(new TValue(t0.AddMinutes(i), 100.0));
+        }
+
+        var ind = new Maenv(20, 1.0, MaenvType.EMA);
+
+        foreach (var tv in series)
+        {
+            ind.Update(tv);
+        }
+
+        // EMA should converge to 100 due to warmup compensation
+        Assert.InRange(ind.Last.Value, 99.99, 100.01);
+        Assert.InRange(ind.Upper.Value, 100.99, 101.01);
+        Assert.InRange(ind.Lower.Value, 98.99, 99.01);
+
+        _output.WriteLine("Maenv EMA convergence validated");
+    }
+
+    [Fact]
+    public void Validate_ManualCalculation_WMA()
+    {
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        // WMA(3) weights: newest=9, middle=6, oldest=3 (total=18)
+        series.Add(new TValue(t0, 100)); // First bar: WMA = 100
+        series.Add(new TValue(t0.AddMinutes(1), 110)); // WMA = (110*9 + 100*6) / 15 = 1590/15 = 106
+        series.Add(new TValue(t0.AddMinutes(2), 120)); // WMA = (120*9 + 110*6 + 100*3) / 18 = 1980/18 = 110
+
+        var ind = new Maenv(3, 1.0, MaenvType.WMA);
+
+        ind.Update(series[0]);
+        Assert.Equal(100.0, ind.Last.Value, 1e-10);
+
+        ind.Update(series[1]);
+        double expected2 = (110.0 * 9 + 100.0 * 6) / 15.0;
+        Assert.Equal(expected2, ind.Last.Value, 1e-10);
+
+        ind.Update(series[2]);
+        double expected3 = (120.0 * 9 + 110.0 * 6 + 100.0 * 3) / 18.0;
+        Assert.Equal(expected3, ind.Last.Value, 1e-10);
+
+        _output.WriteLine("Maenv WMA manual calculation validated");
+    }
+
+    [Fact]
+    public void Validate_AllModes_Consistency()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double[] percentages = { 0.5, 1.0, 2.0, 5.0 };
+
+        foreach (int period in periods)
+        {
+            foreach (double percentage in percentages)
+            {
+                foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+                {
+                    // Batch (instance)
+                    var inst = new Maenv(period, percentage, maType);
+                    var (bMid, bUp, bLo) = inst.Update(_testData.Data);
+
+                    // Static batch
+                    var (sMid, sUp, sLo) = Maenv.Batch(_testData.Data, period, percentage, maType);
+
+                    ValidationHelper.VerifySeriesEqual(bMid, sMid);
+                    ValidationHelper.VerifySeriesEqual(bUp, sUp);
+                    ValidationHelper.VerifySeriesEqual(bLo, sLo);
+
+                    // Streaming
+                    var streaming = new Maenv(period, percentage, maType);
+                    var sMidStream = new TSeries();
+                    var sUpStream = new TSeries();
+                    var sLoStream = new TSeries();
+                    foreach (var tv in _testData.Data)
+                    {
+                        streaming.Update(tv);
+                        sMidStream.Add(streaming.Last);
+                        sUpStream.Add(streaming.Upper);
+                        sLoStream.Add(streaming.Lower);
+                    }
+
+                    ValidationHelper.VerifySeriesEqual(sMid, sMidStream);
+                    ValidationHelper.VerifySeriesEqual(sUp, sUpStream);
+                    ValidationHelper.VerifySeriesEqual(sLo, sLoStream);
+
+                    // Span
+                    double[] source = _testData.ClosePrices.ToArray();
+                    double[] spanMid = new double[source.Length];
+                    double[] spanUp = new double[source.Length];
+                    double[] spanLo = new double[source.Length];
+                    Maenv.Batch(source.AsSpan(), spanMid.AsSpan(), spanUp.AsSpan(), spanLo.AsSpan(), period, percentage, maType);
+
+                    for (int i = 0; i < source.Length; i++)
+                    {
+                        Assert.Equal(sMid[i].Value, spanMid[i], 9);
+                        Assert.Equal(sUp[i].Value, spanUp[i], 9);
+                        Assert.Equal(sLo[i].Value, spanLo[i], 9);
+                    }
+                }
+            }
+        }
+
+        _output.WriteLine("Maenv mode consistency validated (batch/stream/span) for all MA types");
+    }
+
+    [Fact]
+    public void Validate_EventingMode_MatchesBatch()
+    {
+        const int period = 20;
+        const double percentage = 2.0;
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var pub = new TSeries();
+            var evtInd = new Maenv(pub, period, percentage, maType);
+            var evtMid = new TSeries();
+            var evtUp = new TSeries();
+            var evtLo = new TSeries();
+
+            foreach (var tv in _testData.Data)
+            {
+                pub.Add(tv);
+                evtMid.Add(evtInd.Last);
+                evtUp.Add(evtInd.Upper);
+                evtLo.Add(evtInd.Lower);
+            }
+
+            var (bMid, bUp, bLo) = Maenv.Batch(_testData.Data, period, percentage, maType);
+
+            ValidationHelper.VerifySeriesEqual(bMid, evtMid);
+            ValidationHelper.VerifySeriesEqual(bUp, evtUp);
+            ValidationHelper.VerifySeriesEqual(bLo, evtLo);
+        }
+
+        _output.WriteLine("Maenv eventing mode validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_Calculate_ReturnsHotIndicator()
+    {
+        const int period = 15;
+        const double percentage = 2.5;
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ((mid, up, lo), ind) = Maenv.Calculate(_testData.Data, period, percentage, maType);
+
+            Assert.True(ind.IsHot);
+            Assert.Equal(period, ind.WarmupPeriod);
+            Assert.Equal(mid.Last.Value, ind.Last.Value, 1e-10);
+            Assert.Equal(up.Last.Value, ind.Upper.Value, 1e-10);
+            Assert.Equal(lo.Last.Value, ind.Lower.Value, 1e-10);
+
+            // Continue streaming
+            var next = new TValue(DateTime.UtcNow, 100);
+            ind.Update(next);
+            Assert.True(ind.IsHot);
+        }
+
+        _output.WriteLine("Maenv Calculate validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_Prime_MatchesBatch()
+    {
+        const int period = 25;
+        const double percentage = 1.5;
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var (bMid, bUp, bLo) = Maenv.Batch(_testData.Data, period, percentage, maType);
+
+            var primed = new Maenv(period, percentage, maType);
+            var subset = new TSeries();
+            for (int i = 0; i < 200; i++)
+            {
+                subset.Add(_testData.Data[i]);
+            }
+
+            primed.Prime(subset);
+
+            for (int i = 200; i < _testData.Data.Count; i++)
+            {
+                primed.Update(_testData.Data[i]);
+            }
+
+            Assert.Equal(bMid.Last.Value, primed.Last.Value, 1e-9);
+            Assert.Equal(bUp.Last.Value, primed.Upper.Value, 1e-9);
+            Assert.Equal(bLo.Last.Value, primed.Lower.Value, 1e-9);
+        }
+
+        _output.WriteLine("Maenv Prime validated against batch for all MA types");
+    }
+
+    [Fact]
+    public void Validate_LargeDataset_FiniteOutputs()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var (mid, up, lo) = Maenv.Batch(_testData.Data, 50, 2.0, maType);
+
+            ValidationHelper.VerifyAllFinite(mid, startIndex: 0);
+            ValidationHelper.VerifyAllFinite(up, startIndex: 0);
+            ValidationHelper.VerifyAllFinite(lo, startIndex: 0);
+
+            // Upper > Lower for all bars (positive prices)
+            for (int i = 0; i < mid.Count; i++)
+            {
+                Assert.True(up[i].Value > lo[i].Value, $"Upper > Lower at {i} for {maType}");
+            }
+        }
+
+        _output.WriteLine("Maenv large dataset validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_BandSymmetry_AllBars()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new Maenv(20, 2.0, maType);
+            var (mid, up, lo) = ind.Update(_testData.Data);
+
+            for (int i = 0; i < mid.Count; i++)
+            {
+                double upperWidth = up[i].Value - mid[i].Value;
+                double lowerWidth = mid[i].Value - lo[i].Value;
+                Assert.Equal(upperWidth, lowerWidth, 1e-10);
+            }
+        }
+
+        _output.WriteLine("Maenv band symmetry validated for all bars and MA types");
+    }
+
+    [Fact]
+    public void Validate_PercentageScaling()
+    {
+        double[] percentages = { 1.0, 2.0, 3.0, 4.0 };
+        double[] widths = new double[percentages.Length];
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            for (int i = 0; i < percentages.Length; i++)
+            {
+                var ind = new Maenv(20, percentages[i], maType);
+                foreach (var tv in _testData.Data)
+                {
+                    ind.Update(tv);
+                }
+                widths[i] = ind.Upper.Value - ind.Lower.Value;
+            }
+
+            // Widths should scale linearly with percentage
+            double baseWidth = widths[0];
+            for (int i = 1; i < percentages.Length; i++)
+            {
+                double expected = baseWidth * percentages[i];
+                Assert.Equal(expected, widths[i], 1e-9);
+            }
+        }
+
+        _output.WriteLine("Maenv percentage scaling validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_PeriodEffect_Smoothing()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double[] middles = new double[periods.Length];
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            for (int i = 0; i < periods.Length; i++)
+            {
+                var ind = new Maenv(periods[i], 2.0, maType);
+                foreach (var tv in _testData.Data)
+                {
+                    ind.Update(tv);
+                }
+                middles[i] = ind.Last.Value;
+            }
+
+            // All should produce finite values
+            foreach (var m in middles)
+            {
+                Assert.True(double.IsFinite(m));
+            }
+        }
+
+        _output.WriteLine("Maenv period effect validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_StateRestoration_Iterative()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new Maenv(15, 2.5, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+            // Build up state
+            for (int i = 0; i < 50; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                ind.Update(new TValue(bar.Time, bar.Close), isNew: true);
+            }
+
+            // Multiple corrections
+            var rememberedBar = gbm.Next(isNew: true);
+            var remembered = new TValue(rememberedBar.Time, rememberedBar.Close);
+            ind.Update(remembered, isNew: true);
+
+            double midBefore = ind.Last.Value;
+            double upBefore = ind.Upper.Value;
+            double loBefore = ind.Lower.Value;
+
+            for (int i = 0; i < 10; i++)
+            {
+                var corrected = gbm.Next(isNew: false);
+                ind.Update(new TValue(corrected.Time, corrected.Close), isNew: false);
+            }
+
+            // Restore with remembered value
+            ind.Update(remembered, isNew: false);
+
+            Assert.Equal(midBefore, ind.Last.Value, 1e-6);
+            Assert.Equal(upBefore, ind.Upper.Value, 1e-6);
+            Assert.Equal(loBefore, ind.Lower.Value, 1e-6);
+        }
+
+        _output.WriteLine("Maenv state restoration validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_BandWidthFormula()
+    {
+        // Band width = 2 * middle * percentage / 100
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new Maenv(20, 3.0, maType);
+
+            foreach (var tv in _testData.Data)
+            {
+                ind.Update(tv);
+
+                double expectedWidth = 2 * ind.Last.Value * 3.0 / 100.0;
+                double actualWidth = ind.Upper.Value - ind.Lower.Value;
+                Assert.Equal(expectedWidth, actualWidth, 1e-10);
+            }
+        }
+
+        _output.WriteLine("Maenv band width formula validated");
+    }
+
+    [Fact]
+    public void Validate_MaTypesDifferent()
+    {
+        // Different MA types should produce different results (except for first bar)
+        var indSma = new Maenv(10, 2.0, MaenvType.SMA);
+        var indEma = new Maenv(10, 2.0, MaenvType.EMA);
+        var indWma = new Maenv(10, 2.0, MaenvType.WMA);
+
+        var gbm = new GBM(startPrice: 100, mu: 0.02, sigma: 0.15, seed: 42);
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            var tv = new TValue(bar.Time, bar.Close);
+            indSma.Update(tv);
+            indEma.Update(tv);
+            indWma.Update(tv);
+        }
+
+        // Values should be different (with high probability)
+        bool allSame = Math.Abs(indSma.Last.Value - indEma.Last.Value) < 1e-10 &&
+                       Math.Abs(indEma.Last.Value - indWma.Last.Value) < 1e-10;
+        Assert.False(allSame, "Different MA types should produce different values");
+
+        _output.WriteLine("Maenv MA types produce different results validated");
+    }
+
+    [Fact]
+    public void Validate_WarmupCompensation_EMA()
+    {
+        // EMA should converge quickly due to warmup compensation
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        for (int i = 0; i < 100; i++)
+        {
+            series.Add(new TValue(t0.AddMinutes(i), 100.0));
+        }
+
+        var ind = new Maenv(20, 1.0, MaenvType.EMA);
+        var (mid, _, _) = ind.Update(series);
+
+        // After warmup, middle should be very close to constant price
+        for (int i = 40; i < 100; i++)
+        {
+            Assert.InRange(mid[i].Value, 99.9, 100.1);
+        }
+
+        _output.WriteLine("Maenv EMA warmup compensation validated");
+    }
+
+    [Fact]
+    public void Validate_SMA_RingBuffer_O1()
+    {
+        // SMA should maintain O(1) computation via ring buffer
+        // Test that it produces correct rolling average
+        var ind = new Maenv(5, 1.0, MaenvType.SMA);
+        var values = new double[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
+
+        for (int i = 0; i < values.Length; i++)
+        {
+            ind.Update(new TValue(DateTime.UtcNow, values[i]));
+
+            // Calculate expected SMA
+            int start = Math.Max(0, i - 4);
+            double sum = 0;
+            for (int j = start; j <= i; j++)
+            {
+                sum += values[j];
+            }
+            double expected = sum / (i - start + 1);
+
+            Assert.Equal(expected, ind.Last.Value, 1e-10);
+        }
+
+        _output.WriteLine("Maenv SMA ring buffer O(1) validated");
+    }
+}
@@ -0,0 +1,563 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// MA Type enumeration for MAENV indicator.
+/// </summary>
+public enum MaenvType
+{
+    /// <summary>Simple Moving Average (O(1) with ring buffer)</summary>
+    SMA = 0,
+    /// <summary>Exponential Moving Average (O(1) with warmup)</summary>
+    EMA = 1,
+    /// <summary>Weighted Moving Average (O(n))</summary>
+    WMA = 2
+}
+
+/// <summary>
+/// MAENV: Moving Average Envelope
+/// A percentage-based envelope using a selectable moving average as the middle line.
+/// Middle = MA(source, period) - SMA, EMA, or WMA
+/// Upper = Middle + (Middle × percentage / 100)
+/// Lower = Middle - (Middle × percentage / 100)
+/// </summary>
+[SkipLocalsInit]
+public sealed class Maenv : ITValuePublisher
+{
+    private readonly int _period;
+    private readonly double _percentage;
+    private readonly MaenvType _maType;
+    private readonly double _emaAlpha;
+
+    // Ring buffer for SMA
+    private readonly double[]? _smaBuffer;
+
+    [StructLayout(LayoutKind.Auto)]
+    private record struct State(
+        // EMA state
+        double EmaSum,
+        double EmaWeight,
+        // SMA state
+        double SmaSum,
+        int SmaHead,
+        int SmaCount,
+        // WMA state
+        int WmaCount,
+        // General
+        double LastValid,
+        int Bars,
+        bool IsHot);
+
+    private State _state;
+    private State _p_state;
+    private double[]? _p_smaBuffer;
+
+    // WMA lookback buffer
+    private readonly double[]? _wmaBuffer;
+    private double[]? _p_wmaBuffer;
+
+    private readonly TValuePublishedHandler _valueHandler;
+
+    public string Name { get; }
+    public int WarmupPeriod { get; }
+    public TValue Last { get; private set; }
+    public TValue Upper { get; private set; }
+    public TValue Lower { get; private set; }
+    public bool IsHot => _state.IsHot;
+
+    public event TValuePublishedHandler? Pub;
+
+    public Maenv(int period = 20, double percentage = 1.0, MaenvType maType = MaenvType.EMA)
+    {
+        if (period < 1)
+            throw new ArgumentOutOfRangeException(nameof(period), "Period must be >= 1.");
+        if (percentage <= 0.0)
+            throw new ArgumentOutOfRangeException(nameof(percentage), "Percentage must be > 0.");
+
+        _period = period;
+        _percentage = percentage;
+        _maType = maType;
+        _emaAlpha = 2.0 / (period + 1);
+
+        WarmupPeriod = period;
+
+        Name = $"Maenv({period},{percentage},{maType})";
+        _valueHandler = HandleValue;
+
+        // Allocate buffers based on MA type
+        if (maType == MaenvType.SMA)
+        {
+            _smaBuffer = new double[period];
+            _p_smaBuffer = new double[period];
+        }
+        else if (maType == MaenvType.WMA)
+        {
+            _wmaBuffer = new double[period];
+            _p_wmaBuffer = new double[period];
+        }
+
+        Reset();
+    }
+
+    public Maenv(TSeries source, int period = 20, double percentage = 1.0, MaenvType maType = MaenvType.EMA) : this(period, percentage, maType)
+    {
+        Prime(source);
+        source.Pub += _valueHandler;
+    }
+
+    private void HandleValue(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void PubEvent(TValue value, bool isNew = true) =>
+        Pub?.Invoke(this, new TValueEventArgs { Value = value, IsNew = isNew });
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Reset()
+    {
+        _state = new State(0, 0, 0, 0, 0, 0, double.NaN, 0, false);
+        _p_state = _state;
+
+        if (_smaBuffer != null)
+        {
+            Array.Fill(_smaBuffer, 0.0);
+            _p_smaBuffer = (double[])_smaBuffer.Clone();
+        }
+
+        if (_wmaBuffer != null)
+        {
+            Array.Fill(_wmaBuffer, 0.0);
+            _p_wmaBuffer = (double[])_wmaBuffer.Clone();
+        }
+
+        Last = default;
+        Upper = default;
+        Lower = default;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double GetValid(double value, bool isNew)
+    {
+        if (double.IsFinite(value))
+        {
+            if (isNew)
+                _state = _state with { LastValid = value };
+            return value;
+        }
+        return _state.LastValid;
+    }
+
+    // ========================
+    // Update overloads (adjacent per S4136)
+    // ========================
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TValue Update(TValue input, bool isNew = true)
+    {
+        if (isNew)
+        {
+            _p_state = _state;
+            if (_smaBuffer != null && _p_smaBuffer != null)
+                Array.Copy(_smaBuffer, _p_smaBuffer, _period);
+            if (_wmaBuffer != null && _p_wmaBuffer != null)
+                Array.Copy(_wmaBuffer, _p_wmaBuffer, _period);
+        }
+        else
+        {
+            _state = _p_state;
+            if (_smaBuffer != null && _p_smaBuffer != null)
+                Array.Copy(_p_smaBuffer, _smaBuffer, _period);
+            if (_wmaBuffer != null && _p_wmaBuffer != null)
+                Array.Copy(_p_wmaBuffer, _wmaBuffer, _period);
+        }
+
+        double value = GetValid(input.Value, isNew);
+
+        if (isNew)
+            _state = _state with { Bars = _state.Bars + 1 };
+
+        double middle = _maType switch
+        {
+            MaenvType.SMA => CalculateSMA(value, isNew),
+            MaenvType.EMA => CalculateEMA(value, isNew),
+            MaenvType.WMA => CalculateWMA(value, isNew),
+            _ => value
+        };
+
+        double dist = middle * _percentage / 100.0;
+        double upper = middle + dist;
+        double lower = middle - dist;
+
+        if (!_state.IsHot && _state.Bars >= WarmupPeriod)
+            _state = _state with { IsHot = true };
+
+        Last = new TValue(input.Time, middle);
+        Upper = new TValue(input.Time, upper);
+        Lower = new TValue(input.Time, lower);
+
+        PubEvent(Last, isNew);
+        return Last;
+    }
+
+    public (TSeries Middle, TSeries Upper, TSeries Lower) Update(TSeries source)
+    {
+        if (source.Count == 0)
+            return (new TSeries([], []), new TSeries([], []), new TSeries([], []));
+
+        int len = source.Count;
+        var tMiddle = new List<long>(len);
+        var vMiddle = new List<double>(len);
+        var tUpper = new List<long>(len);
+        var vUpper = new List<double>(len);
+        var tLower = new List<long>(len);
+        var vLower = new List<double>(len);
+
+        CollectionsMarshal.SetCount(tMiddle, len);
+        CollectionsMarshal.SetCount(vMiddle, len);
+        CollectionsMarshal.SetCount(tUpper, len);
+        CollectionsMarshal.SetCount(vUpper, len);
+        CollectionsMarshal.SetCount(tLower, len);
+        CollectionsMarshal.SetCount(vLower, len);
+
+        var tSpan = CollectionsMarshal.AsSpan(tMiddle);
+        var vMiddleSpan = CollectionsMarshal.AsSpan(vMiddle);
+        var vUpperSpan = CollectionsMarshal.AsSpan(vUpper);
+        var vLowerSpan = CollectionsMarshal.AsSpan(vLower);
+
+        Batch(source.Values, vMiddleSpan, vUpperSpan, vLowerSpan, _period, _percentage, _maType);
+
+        source.Times.CopyTo(tSpan);
+        tSpan.CopyTo(CollectionsMarshal.AsSpan(tUpper));
+        tSpan.CopyTo(CollectionsMarshal.AsSpan(tLower));
+
+        // Prime internal state for continued streaming
+        Prime(source);
+
+        var lastTime = new DateTime(source.Times[^1], DateTimeKind.Utc);
+        Last = new TValue(lastTime, vMiddleSpan[^1]);
+        Upper = new TValue(lastTime, vUpperSpan[^1]);
+        Lower = new TValue(lastTime, vLowerSpan[^1]);
+
+        return (new TSeries(tMiddle, vMiddle), new TSeries(tUpper, vUpper), new TSeries(tLower, vLower));
+    }
+
+    // ========================
+    // Private MA calculation helpers
+    // ========================
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double CalculateSMA(double value, bool isNew)
+    {
+        if (_smaBuffer == null) return value;
+
+        // Calculate new count (always increment if not full, for both isNew cases)
+        int currentCount = _state.SmaCount;
+        int calcCount = currentCount < _period ? currentCount + 1 : currentCount;
+
+        // Remove oldest value from sum if buffer is full
+        double oldest = _smaBuffer[_state.SmaHead];
+        double newSum = _state.SmaSum;
+
+        if (currentCount >= _period)
+        {
+            newSum -= oldest;
+        }
+
+        // Add new value
+        newSum += value;
+
+        // Update buffer
+        _smaBuffer[_state.SmaHead] = value;
+        int newHead = (_state.SmaHead + 1) % _period;
+
+        // Persist state only for isNew=true
+        if (isNew)
+        {
+            _state = _state with
+            {
+                SmaSum = newSum,
+                SmaHead = newHead,
+                SmaCount = calcCount
+            };
+        }
+
+        return newSum / calcCount;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double CalculateEMA(double value, bool isNew)
+    {
+        // Use EmaWeight==0 to detect first value for correct isNew=false behavior
+        if (_state.EmaWeight == 0)
+        {
+            // First value - persist only for isNew=true
+            if (isNew)
+            {
+                _state = _state with
+                {
+                    EmaSum = value,
+                    EmaWeight = 1.0
+                };
+            }
+            return value;
+        }
+
+        // EMA with warmup compensation
+        double newSum = Math.FusedMultiplyAdd(_state.EmaSum, 1.0 - _emaAlpha, value * _emaAlpha);
+        double newWeight = Math.FusedMultiplyAdd(_state.EmaWeight, 1.0 - _emaAlpha, _emaAlpha);
+
+        // Persist state only for isNew=true
+        if (isNew)
+        {
+            _state = _state with
+            {
+                EmaSum = newSum,
+                EmaWeight = newWeight
+            };
+        }
+
+        return newSum / newWeight;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double CalculateWMA(double value, bool isNew)
+    {
+        if (_wmaBuffer == null) return value;
+
+        // Calculate count for this bar (always increment if not full, for both isNew cases)
+        int currentCount = _state.WmaCount;
+        int calcCount = currentCount < _period ? currentCount + 1 : currentCount;
+
+        // Shift buffer (always shift if count > 1, regardless of isNew)
+        // This ensures restoration produces same buffer state as original
+        if (calcCount > 1)
+        {
+            for (int i = _period - 1; i > 0; i--)
+                _wmaBuffer[i] = _wmaBuffer[i - 1];
+        }
+        _wmaBuffer[0] = value;
+
+        // Persist state only for isNew=true
+        if (isNew)
+            _state = _state with { WmaCount = calcCount };
+
+        // Calculate WMA
+        double norm = 0.0;
+        double sum = 0.0;
+
+        for (int i = 0; i < calcCount; i++)
+        {
+            double w = (_period - i) * _period;
+            norm += w;
+            sum += _wmaBuffer[i] * w;
+        }
+
+        return norm > 0 ? sum / norm : value;
+    }
+
+    public void Prime(TSeries source)
+    {
+        Reset();
+
+        if (source.Count == 0)
+            return;
+
+        for (int i = 0; i < source.Count; i++)
+        {
+            Update(source[i], isNew: true);
+        }
+    }
+
+    // ========================
+    // Batch overloads (adjacent per S4136)
+    // ========================
+
+    /// <summary>
+    /// Batch calculation using spans (zero allocation for SMA and EMA).
+    /// </summary>
+    public static void Batch(
+        ReadOnlySpan<double> source,
+        Span<double> middle,
+        Span<double> upper,
+        Span<double> lower,
+        int period,
+        double percentage = 1.0,
+        MaenvType maType = MaenvType.EMA)
+    {
+        if (period < 1)
+            throw new ArgumentOutOfRangeException(nameof(period), "Period must be >= 1.");
+        if (percentage <= 0.0)
+            throw new ArgumentOutOfRangeException(nameof(percentage), "Percentage must be > 0.");
+        if (middle.Length < source.Length || upper.Length < source.Length || lower.Length < source.Length)
+            throw new ArgumentException("Output spans must be at least as long as input", nameof(middle));
+
+        int len = source.Length;
+        if (len == 0) return;
+
+        switch (maType)
+        {
+            case MaenvType.SMA:
+                BatchSMA(source, middle, upper, lower, period, percentage);
+                break;
+            case MaenvType.EMA:
+                BatchEMA(source, middle, upper, lower, period, percentage);
+                break;
+            case MaenvType.WMA:
+                BatchWMA(source, middle, upper, lower, period, percentage);
+                break;
+        }
+    }
+
+    public static (TSeries Middle, TSeries Upper, TSeries Lower) Batch(TSeries source, int period = 20, double percentage = 1.0, MaenvType maType = MaenvType.EMA)
+    {
+        int len = source.Count;
+        var tMiddle = new List<long>(len);
+        var vMiddle = new List<double>(len);
+        var tUpper = new List<long>(len);
+        var vUpper = new List<double>(len);
+        var tLower = new List<long>(len);
+        var vLower = new List<double>(len);
+
+        CollectionsMarshal.SetCount(tMiddle, len);
+        CollectionsMarshal.SetCount(vMiddle, len);
+        CollectionsMarshal.SetCount(tUpper, len);
+        CollectionsMarshal.SetCount(vUpper, len);
+        CollectionsMarshal.SetCount(tLower, len);
+        CollectionsMarshal.SetCount(vLower, len);
+
+        Batch(source.Values,
+              CollectionsMarshal.AsSpan(vMiddle),
+              CollectionsMarshal.AsSpan(vUpper),
+              CollectionsMarshal.AsSpan(vLower),
+              period, percentage, maType);
+
+        source.Times.CopyTo(CollectionsMarshal.AsSpan(tMiddle));
+        CollectionsMarshal.AsSpan(tMiddle).CopyTo(CollectionsMarshal.AsSpan(tUpper));
+        CollectionsMarshal.AsSpan(tMiddle).CopyTo(CollectionsMarshal.AsSpan(tLower));
+
+        return (new TSeries(tMiddle, vMiddle), new TSeries(tUpper, vUpper), new TSeries(tLower, vLower));
+    }
+
+    // ========================
+    // Private batch helpers
+    // ========================
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void BatchSMA(
+        ReadOnlySpan<double> source,
+        Span<double> middle,
+        Span<double> upper,
+        Span<double> lower,
+        int period,
+        double percentage)
+    {
+        int len = source.Length;
+        Span<double> buffer = period <= 256 ? stackalloc double[period] : new double[period];
+        buffer.Clear();
+
+        double sum = 0.0;
+        int head = 0;
+        int count = 0;
+
+        for (int i = 0; i < len; i++)
+        {
+            double value = source[i];
+
+            // Remove oldest if full
+            if (count >= period)
+            {
+                sum -= buffer[head];
+            }
+            else
+            {
+                count++;
+            }
+
+            // Add new
+            sum += value;
+            buffer[head] = value;
+            head = (head + 1) % period;
+
+            double ma = sum / count;
+            double dist = ma * percentage / 100.0;
+            middle[i] = ma;
+            upper[i] = ma + dist;
+            lower[i] = ma - dist;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void BatchEMA(
+        ReadOnlySpan<double> source,
+        Span<double> middle,
+        Span<double> upper,
+        Span<double> lower,
+        int period,
+        double percentage)
+    {
+        int len = source.Length;
+        double alpha = 2.0 / (period + 1);
+        double emaSum = source[0];
+        double emaWeight = 1.0;
+
+        double ma = emaSum;
+        double dist = ma * percentage / 100.0;
+        middle[0] = ma;
+        upper[0] = ma + dist;
+        lower[0] = ma - dist;
+
+        for (int i = 1; i < len; i++)
+        {
+            double value = source[i];
+
+            emaSum = Math.FusedMultiplyAdd(emaSum, 1.0 - alpha, value * alpha);
+            emaWeight = Math.FusedMultiplyAdd(emaWeight, 1.0 - alpha, alpha);
+
+            ma = emaSum / emaWeight;
+            dist = ma * percentage / 100.0;
+            middle[i] = ma;
+            upper[i] = ma + dist;
+            lower[i] = ma - dist;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void BatchWMA(
+        ReadOnlySpan<double> source,
+        Span<double> middle,
+        Span<double> upper,
+        Span<double> lower,
+        int period,
+        double percentage)
+    {
+        int len = source.Length;
+
+        for (int i = 0; i < len; i++)
+        {
+            double norm = 0.0;
+            double sum = 0.0;
+            int count = Math.Min(i + 1, period);
+
+            for (int j = 0; j < count; j++)
+            {
+                double w = (period - j) * period;
+                norm += w;
+                sum += source[i - j] * w;
+            }
+
+            double ma = norm > 0 ? sum / norm : source[i];
+            double dist = ma * percentage / 100.0;
+            middle[i] = ma;
+            upper[i] = ma + dist;
+            lower[i] = ma - dist;
+        }
+    }
+
+    public static ((TSeries Middle, TSeries Upper, TSeries Lower) Results, Maenv Indicator) Calculate(TSeries source, int period = 20, double percentage = 1.0, MaenvType maType = MaenvType.EMA)
+    {
+        var indicator = new Maenv(source, period, percentage, maType);
+        var results = indicator.Update(source);
+        return (results, indicator);
+    }
+}
@@ -1,98 +1,161 @@
-# Moving Average Envelope
+# MAENV: Moving Average Envelope

-Moving Average Envelope consists of three lines: a moving average in the middle and two lines plotted at a fixed percentage above and below it. The envelope provides a simple way to identify potential support and resistance levels based on a percentage deviation from the average price.
+> "The simplest channels are often the most useful - a percentage above and below tells you when price is stretched."

-## Calculation
+The Moving Average Envelope (MAENV) creates a fixed percentage-based channel around a selectable moving average. Unlike volatility-adaptive channels like Keltner or Bollinger Bands, MAENV maintains constant proportional distance from the middle line, making it useful for mean-reversion strategies where you expect price to oscillate within predictable bounds.

-```
-Middle = MA(Source, Length)
-Upper = Middle + (Middle × Percentage/100)
-Lower = Middle - (Middle × Percentage/100)
-```
+## Historical Context

-Where:
-* MA = Moving Average (can be SMA, EMA, or WMA)
-* Source = Price series (typically close price)
-* Length = Lookback period for moving average
-* Percentage = Fixed percentage for band width
+Moving Average Envelopes are among the oldest channel indicators, predating volatility-based bands by decades. The concept is straightforward: if price tends to revert to a moving average, then defining zones at fixed percentages above and below that average provides natural support and resistance levels.

-## Parameters
+The choice of moving average type affects responsiveness:

-* Source (default: close) - Price series used for the moving average
-* Length (default: 20) - Period used for moving average calculation
-* Percentage (default: 1.0) - Fixed percentage distance from MA to bands
-* MA Type (default: 1) - Moving average type: 0:SMA, 1:EMA, or 2:WMA
+- **SMA**: Equal weighting creates stable, predictable bands but slower reaction to price changes
+- **EMA**: Exponential weighting responds faster to recent prices, making bands more dynamic
+- **WMA**: Linear weighting provides a middle ground, emphasizing recent data without the sharp responsiveness of EMA

-## Interpretation
+This implementation offers all three options, letting traders choose the smoothing behavior that matches their strategy.

-* The middle line shows the average price trend
-* Upper and lower bands create a channel based on fixed percentage
-* Price reaching the bands may indicate overbought/oversold conditions
-* Unlike volatility-based bands, envelope width changes proportionally with price
-* Band penetration may signal potential trend reversals
-* Works best in trending markets with consistent volatility
+## Architecture & Physics

-## Implementation
+### 1. Moving Average Calculation

-The implementation includes:
-* Choice of three moving average types (SMA, EMA, WMA)
-* Optimized calculations for each MA type
-* Circular buffer for efficient SMA calculation
-* Alpha smoothing for EMA
-* Linear weighting for WMA
-* Proper handling of NA values
-* Input validation
-* Percentage-based band width calculation
+The middle band is computed using the selected MA type:
+
+**SMA (Simple Moving Average)** - O(1) streaming via ring buffer:
+
+$$
+\text{SMA}_t = \frac{1}{n} \sum_{i=0}^{n-1} P_{t-i}
+$$
+
+Implementation uses circular buffer to maintain running sum, achieving constant-time updates.
+
+**EMA (Exponential Moving Average)** - O(1) with warmup compensation:
+
+$$
+\alpha = \frac{2}{n+1}
+$$
+
+$$
+\text{sum}_t = \text{sum}_{t-1}(1-\alpha) + P_t \cdot \alpha
+$$
+
+$$
+\text{weight}_t = \text{weight}_{t-1}(1-\alpha) + \alpha
+$$
+
+$$
+\text{EMA}_t = \frac{\text{sum}_t}{\text{weight}_t}
+$$
+
+Warmup compensation ensures accurate values from the first bar by tracking both weighted sum and weight.
+
+**WMA (Weighted Moving Average)** - O(n):
+
+$$
+\text{WMA}_t = \frac{\sum_{i=0}^{n-1} w_i \cdot P_{t-i}}{\sum_{i=0}^{n-1} w_i}
+$$
+
+where $w_i = (n-i) \times n$ giving highest weight to most recent values.
+
+### 2. Band Calculation
+
+Bands are symmetric percentage-based offsets:
+
+$$
+\text{dist}_t = \text{Middle}_t \times \frac{\text{percentage}}{100}
+$$
+
+$$
+\text{Upper}_t = \text{Middle}_t + \text{dist}_t
+$$
+
+$$
+\text{Lower}_t = \text{Middle}_t - \text{dist}_t
+$$
+
+## Mathematical Foundation
+
+### Band Width Formula
+
+Total band width scales linearly with both the middle value and percentage parameter:
+
+$$
+\text{Width}_t = \text{Upper}_t - \text{Lower}_t = 2 \times \text{Middle}_t \times \frac{\text{percentage}}{100}
+$$
+
+This creates proportional bands - a 2% envelope means bands are always 4% of the middle value apart.
+
+### EMA Warmup Derivation
+
+Traditional EMA initialization (`EMA_0 = P_0`) creates bias when the first value differs significantly from subsequent values. The warmup compensation tracks:
+
+$$
+\text{theoretical\_weight} = \alpha \sum_{i=0}^{t} (1-\alpha)^i = 1 - (1-\alpha)^{t+1}
+$$
+
+By dividing sum by actual accumulated weight, the EMA converges to the true value faster and without initialization bias.

 ## Performance Profile

-### Operation Count (Streaming Mode, per Bar)
+### Operation Count (Streaming Mode)

-| Operation | EMA Type | SMA Type | WMA Type | Cost |
-| :--- | :---: | :---: | :---: | :---: |
-| ADD/SUB | 2 | 2 | 1 | 1 cycle |
-| MUL | 4 | 2 | 2 | 3 cycles |
-| DIV | 0 | 1 | 1 | 15 cycles |
+| MA Type | Per-Bar Cost | Memory | Complexity |
+| :--- | :---: | :---: | :---: |
+| SMA | ~5 ops | O(n) buffer | O(1) |
+| EMA | ~8 ops | O(1) scalars | O(1) |
+| WMA | ~3n ops | O(n) buffer | O(n) |

-**Per-bar totals:**
- **EMA type**: 2×1 + 4×3 = ~14 cycles
- **SMA type**: 2×1 + 2×3 + 1×15 = ~23 cycles (running sum)
- **WMA type**: 1×1 + 2×3 + 1×15 = ~22 cycles (running sums)
+SMA and EMA achieve constant-time streaming updates. WMA requires linear time due to weighted sum recalculation.

-### Complexity Analysis
+### Batch Mode Performance

-| Mode | Complexity | Notes |
-| :--- | :---: | :--- |
-| Streaming (EMA) | O(1) | IIR recursion, constant time |
-| Streaming (SMA) | O(1) | Running sum with circular buffer |
-| Streaming (WMA) | O(1) | Incremental weight adjustment |
-| Batch | O(n) | Linear scan, n = series length |
+For batch processing of 1000 values:

-**Memory**: Fixed ~64 bytes state regardless of period.
+| MA Type | Streaming | Batch (SIMD) | Speedup |
+| :--- | :---: | :---: | :---: |
+| SMA | ~5000 ops | ~5000 ops | 1× |
+| EMA | ~8000 ops | ~8000 ops | 1× |
+| WMA | ~3M ops | ~3M ops | 1× |

-### SIMD Analysis
-
-| Optimization | Applicable | Notes |
-| :--- | :---: | :--- |
-| AVX2 vectorization | ❌ | EMA/SMA recursion prevents parallelization |
-| FMA | ✅ | Band calculation: `Middle ± Middle × factor` |
-| Batch parallelism | Partial | Band calc vectorizable after MA computed |
+Limited SIMD benefit due to recursive nature of MA calculations.

 ### Quality Metrics

 | Metric | Score | Notes |
 | :--- | :---: | :--- |
-| **Accuracy** | 10/10 | Exact computation |
-| **Timeliness** | 5/10 | MA lag inherited (period/2 for SMA) |
-| **Overshoot** | 2/10 | Fixed percentage, no volatility adaptation |
-| **Smoothness** | 7/10 | Follows MA smoothness |
+| **Accuracy** | 10/10 | Exact percentage-based calculation |
+| **Timeliness** | 7/10 | Depends on MA type (EMA fastest) |
+| **Stability** | 9/10 | No volatility-driven expansion |
+| **Predictability** | 10/10 | Constant proportional width |

 ## Validation

 | Library | Status | Notes |
 | :--- | :---: | :--- |
-| **TA-Lib** | N/A | Not implemented |
-| **Skender** | N/A | Not implemented |
-| **Tulip** | N/A | Not implemented |
-| **Ooples** | N/A | Not implemented |
-| **Internal** | ✅ | Mode consistency verified |
+| **TA-Lib** | N/A | No direct equivalent |
+| **Skender** | N/A | No direct equivalent |
+| **Tulip** | N/A | No direct equivalent |
+| **Ooples** | N/A | No direct equivalent |
+| **PineScript** | ✅ | Reference implementation match |
+
+Validation performed against internal manual calculations and PineScript reference. No external library provides identical multi-MA-type envelope implementation.
+
+## Common Pitfalls
+
+1. **MA Type Selection**: SMA provides most stable bands but slowest response. EMA responds quickly but may whipsaw. WMA balances both but costs O(n) per update.
+
+2. **Percentage Calibration**: Optimal percentage varies by instrument volatility. Highly volatile assets need wider envelopes (3-5%), stable assets work with narrow bands (0.5-1%).
+
+3. **False Breakouts**: Fixed percentage bands don't adapt to volatility regime changes. Price may consistently breach bands during high-volatility periods.
+
+4. **Warmup Period**: All MA types need `period` bars for full accuracy. EMA warmup compensation accelerates convergence but initial bars still have reduced effective lookback.
+
+5. **Memory Footprint**: SMA and WMA require period-sized buffers (~8 bytes × period per instance). EMA uses only scalar state (~32 bytes total).
+
+6. **Bar Correction (isNew=false)**: State restoration copies entire buffer for SMA/WMA. For large periods, this adds latency to tick-by-tick updates.
+
+## References
+
+- Murphy, J.J. (1999). *Technical Analysis of the Financial Markets*. New York Institute of Finance.
+- TradingView. "Moving Average Envelope." Pine Script Reference.