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-23 04:58:08 +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,281 @@
+using TradingPlatform.BusinessLayer;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class SdchannelIndicatorTests
+{
+    [Fact]
+    public void Constructor_SetsDefaults()
+    {
+        var ind = new SdchannelIndicator();
+
+        Assert.Equal(50, ind.Period);
+        Assert.Equal(2.0, ind.Multiplier);
+        Assert.Equal(PriceType.Close, ind.SourceType);
+        Assert.True(ind.ShowColdValues);
+        Assert.Equal("Sdchannel - Standard Deviation Channel", ind.Name);
+        Assert.False(ind.SeparateWindow);
+        Assert.True(ind.OnBackGround);
+    }
+
+    [Fact]
+    public void MinHistoryDepths_EqualsPeriod()
+    {
+        var ind = new SdchannelIndicator { Period = 30 };
+        Assert.Equal(30, ind.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ShortName_ReflectsParameters()
+    {
+        var ind = new SdchannelIndicator { Period = 20, Multiplier = 2.5 };
+        Assert.Contains("20", ind.ShortName, StringComparison.Ordinal);
+        Assert.Contains("2.5", ind.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Initialize_AddsThreeLineSeries()
+    {
+        var ind = new SdchannelIndicator { Period = 14, Multiplier = 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 SdchannelIndicator { Period = 5, Multiplier = 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 SdchannelIndicator { Period = 5, Multiplier = 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 SdchannelIndicator { Period = 5, Multiplier = 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 SdchannelIndicator { Period = 10, Multiplier = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; 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(30, ind.LinesSeries[0].Count);
+        Assert.Equal(30, ind.LinesSeries[1].Count);
+        Assert.Equal(30, ind.LinesSeries[2].Count);
+
+        for (int i = 0; i < 30; 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 SdchannelIndicator { Period = 10, Multiplier = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        // Add some volatility to ensure non-zero stddev
+        for (int i = 0; i < 20; i++)
+        {
+            double price = 100 + Math.Sin(i * 0.5) * 10;
+            ind.HistoricalData.AddBar(now.AddMinutes(i), price, price + 5, price - 5, price, 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_BandsCollapsed()
+    {
+        var ind = new SdchannelIndicator { Period = 10, Multiplier = 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: stddev = 0, so bands should be at middle
+        Assert.Equal(100.0, middle, 1e-10);
+        Assert.Equal(100.0, upper, 1e-10);
+        Assert.Equal(100.0, lower, 1e-10);
+    }
+
+    [Fact]
+    public void Multiplier_AffectsBandWidth()
+    {
+        var ind1 = new SdchannelIndicator { Period = 10, Multiplier = 1.0 };
+        var ind2 = new SdchannelIndicator { Period = 10, Multiplier = 2.0 };
+        ind1.Initialize();
+        ind2.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            double price = 100 + i * 0.5;
+            ind1.HistoricalData.AddBar(now.AddMinutes(i), price, price + 5, price - 5, price);
+            ind2.HistoricalData.AddBar(now.AddMinutes(i), price, price + 5, price - 5, price);
+            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 SdchannelIndicator { Period = 10, Multiplier = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            double price = 100 + i;
+            ind.HistoricalData.AddBar(now.AddMinutes(i), price, price + 5, price - 5, price);
+            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 LinearData_ZeroStdDev()
+    {
+        var ind = new SdchannelIndicator { Period = 10, Multiplier = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        // Perfect linear data: y = 100 + i
+        for (int i = 0; i < 20; i++)
+        {
+            double price = 100 + i;
+            ind.HistoricalData.AddBar(now.AddMinutes(i), price, price, price, price);
+            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);
+
+        // With perfect linear fit, stddev of residuals is 0
+        Assert.Equal(middle, upper, 1e-9);
+        Assert.Equal(middle, lower, 1e-9);
+    }
+
+    [Fact]
+    public void DifferentPriceTypes_Work()
+    {
+        var indClose = new SdchannelIndicator { Period = 10, Multiplier = 2.0, SourceType = PriceType.Close };
+        var indHigh = new SdchannelIndicator { Period = 10, Multiplier = 2.0, SourceType = PriceType.High };
+        indClose.Initialize();
+        indHigh.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; 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));
+        }
+
+        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");
+    }
+
+    [Fact]
+    public void TrendingData_MiddleFollowsTrend()
+    {
+        var ind = new SdchannelIndicator { Period = 10, Multiplier = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; i++)
+        {
+            double price = 100 + i * 2; // Strong uptrend
+            ind.HistoricalData.AddBar(now.AddMinutes(i), price, price + 2, price - 2, price);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        // After warmup, middle should be close to the current regression line value
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double lastPrice = 100 + 29 * 2; // 158
+
+        // Middle should be close to last price (within reasonable range for regression)
+        Assert.True(Math.Abs(middle - lastPrice) < 10, $"Middle ({middle}) should be close to last price ({lastPrice})");
+    }
+}
@@ -0,0 +1,71 @@
+using System.Drawing;
+using TradingPlatform.BusinessLayer;
+using static QuanTAlib.IndicatorExtensions;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// Sdchannel: Standard Deviation Channel - Quantower Indicator Adapter
+/// Linear regression channel with standard deviation bands.
+/// Middle = Linear regression line value at current bar
+/// Upper = Middle + (StdDev × Multiplier)
+/// Lower = Middle - (StdDev × Multiplier)
+/// </summary>
+public sealed class SdchannelIndicator : Indicator, IWatchlistIndicator
+{
+    [InputParameter("Period", sortIndex: 10, minimum: 2, maximum: 500, increment: 1, decimalPlaces: 0)]
+    public int Period { get; set; } = 50;
+
+    [InputParameter("Multiplier", sortIndex: 20, minimum: 0.1, maximum: 10.0, increment: 0.1, decimalPlaces: 1)]
+    public double Multiplier { get; set; } = 2.0;
+
+    [InputParameter("Price Type", sortIndex: 30)]
+    public PriceType SourceType { get; set; } = PriceType.Close;
+
+    [InputParameter("Show Cold Values", sortIndex: 100)]
+    public bool ShowColdValues { get; set; } = true;
+
+    private Sdchannel? _indicator;
+
+    public int MinHistoryDepths => Period;
+    public override string ShortName => $"Sdchannel({Period},{Multiplier})";
+
+    public SdchannelIndicator()
+    {
+        Name = "Sdchannel - Standard Deviation Channel";
+        Description = "Linear regression channel with standard deviation bands";
+        SeparateWindow = false;
+        OnBackGround = true;
+    }
+
+    protected override void OnInit()
+    {
+        _indicator = new Sdchannel(Period, Multiplier);
+
+        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,426 @@
+using System;
+using QuanTAlib;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class SdchannelTests
+{
+    [Fact]
+    public void Sdchannel_Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Sdchannel(1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Sdchannel(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Sdchannel(-5));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Sdchannel(10, 0.0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Sdchannel(10, -1.0));
+
+        var s = new Sdchannel(10, 2.0);
+        Assert.Equal(10, s.WarmupPeriod);
+        Assert.Contains("Sdchannel", s.Name, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Sdchannel_InitialState_Defaults()
+    {
+        var s = new Sdchannel(5);
+
+        Assert.Equal(0, s.Last.Value);
+        Assert.Equal(0, s.Upper.Value);
+        Assert.Equal(0, s.Lower.Value);
+        Assert.False(s.IsHot);
+        Assert.Equal(0, s.Slope);
+        Assert.Equal(0, s.StdDev);
+    }
+
+    [Fact]
+    public void Sdchannel_FirstValue_AllBandsEqual()
+    {
+        var s = new Sdchannel(10, 2.0);
+
+        var result = s.Update(new TValue(DateTime.UtcNow, 100));
+
+        // First value: regression = input, stdDev = 0, bands equal
+        Assert.Equal(100.0, result.Value, 1e-10);
+        Assert.Equal(100.0, s.Upper.Value, 1e-10);
+        Assert.Equal(100.0, s.Lower.Value, 1e-10);
+        Assert.Equal(0.0, s.Slope, 1e-10);
+        Assert.Equal(0.0, s.StdDev, 1e-10);
+    }
+
+    [Fact]
+    public void Sdchannel_TwoValues_LinearFit()
+    {
+        var s = new Sdchannel(10, 2.0);
+
+        s.Update(new TValue(DateTime.UtcNow, 100));
+        var result = s.Update(new TValue(DateTime.UtcNow, 110));
+
+        // Two points: y=100 at x=0, y=110 at x=1
+        // Regression line: y = 100 + 10*x
+        // At x=1: regression = 110
+        // Both points lie exactly on line, so stdDev = 0
+        Assert.Equal(110.0, result.Value, 1e-10);
+        Assert.Equal(10.0, s.Slope, 1e-10);
+        Assert.Equal(0.0, s.StdDev, 1e-10);
+        Assert.Equal(110.0, s.Upper.Value, 1e-10);
+        Assert.Equal(110.0, s.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Sdchannel_ThreeValues_WithResiduals()
+    {
+        var s = new Sdchannel(10, 1.0);
+
+        // Points: (0,100), (1,120), (2,110)
+        // Sum x = 0+1+2 = 3, Sum x² = 0+1+4 = 5
+        // Sum y = 330, Sum xy = 0*100 + 1*120 + 2*110 = 340
+        // n=3, denom = 3*5 - 3*3 = 6
+        // slope = (3*340 - 3*330) / 6 = (1020 - 990) / 6 = 5
+        // intercept = (330 - 5*3) / 3 = 315/3 = 105
+        // regression at x=2: 105 + 5*2 = 115
+        s.Update(new TValue(DateTime.UtcNow, 100));
+        s.Update(new TValue(DateTime.UtcNow, 120));
+        var result = s.Update(new TValue(DateTime.UtcNow, 110));
+
+        Assert.Equal(115.0, result.Value, 1e-10);
+        Assert.Equal(5.0, s.Slope, 1e-10);
+
+        // Residuals: 100-105=-5, 120-110=10, 110-115=-5
+        // Sum residuals² = 25+100+25 = 150
+        // StdDev = sqrt(150/3) = sqrt(50) ≈ 7.07
+        double expectedStdDev = Math.Sqrt(50);
+        Assert.Equal(expectedStdDev, s.StdDev, 1e-10);
+
+        // Bands at ±1 stdDev
+        Assert.Equal(115.0 + expectedStdDev, s.Upper.Value, 1e-10);
+        Assert.Equal(115.0 - expectedStdDev, s.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Sdchannel_BandWidth_ProportionalToMultiplier()
+    {
+        var s1 = new Sdchannel(10, 1.0);
+        var s2 = new Sdchannel(10, 2.0);
+        var s3 = new Sdchannel(10, 3.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);
+            s1.Update(tv);
+            s2.Update(tv);
+            s3.Update(tv);
+        }
+
+        double width1 = s1.Upper.Value - s1.Lower.Value;
+        double width2 = s2.Upper.Value - s2.Lower.Value;
+        double width3 = s3.Upper.Value - s3.Lower.Value;
+
+        // Width should scale with multiplier (width = 2 * multiplier * stdDev)
+        Assert.Equal(width2, width1 * 2, 1e-9);
+        Assert.Equal(width3, width1 * 3, 1e-9);
+    }
+
+    [Fact]
+    public void Sdchannel_BandOrder_Correct()
+    {
+        var s = new Sdchannel(10, 2.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);
+            s.Update(new TValue(bar.Time, bar.Close));
+
+            // After warmup with real data, bands should separate
+            if (i > 3 && s.StdDev > 0)
+            {
+                Assert.True(s.Upper.Value >= s.Last.Value, $"Upper >= Middle at bar {i}");
+                Assert.True(s.Lower.Value <= s.Last.Value, $"Lower <= Middle at bar {i}");
+            }
+        }
+    }
+
+    [Fact]
+    public void Sdchannel_BandSymmetry_AroundRegression()
+    {
+        var s = new Sdchannel(10, 2.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);
+            s.Update(new TValue(bar.Time, bar.Close));
+
+            // Bands should be symmetric around middle
+            double upperDist = s.Upper.Value - s.Last.Value;
+            double lowerDist = s.Last.Value - s.Lower.Value;
+            Assert.Equal(upperDist, lowerDist, 1e-10);
+
+            // Distance should be exactly multiplier * stdDev
+            double expectedDist = 2.0 * s.StdDev;
+            Assert.Equal(expectedDist, upperDist, 1e-10);
+        }
+    }
+
+    [Fact]
+    public void Sdchannel_ConstantValues_ZeroStdDev()
+    {
+        var s = new Sdchannel(5, 2.0);
+
+        for (int i = 0; i < 20; i++)
+        {
+            s.Update(new TValue(DateTime.UtcNow, 100));
+        }
+
+        // All same values on regression line -> no residuals
+        Assert.Equal(100.0, s.Last.Value, 1e-10);
+        Assert.Equal(0.0, s.Slope, 1e-10);
+        Assert.Equal(0.0, s.StdDev, 1e-10);
+        Assert.Equal(100.0, s.Upper.Value, 1e-10);
+        Assert.Equal(100.0, s.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Sdchannel_LinearTrend_ZeroStdDev()
+    {
+        var s = new Sdchannel(5, 2.0);
+
+        // Perfect linear trend: 100, 102, 104, 106, 108
+        for (int i = 0; i < 5; i++)
+        {
+            s.Update(new TValue(DateTime.UtcNow, 100 + i * 2));
+        }
+
+        // All points lie exactly on regression line
+        Assert.Equal(108.0, s.Last.Value, 1e-10);
+        Assert.Equal(2.0, s.Slope, 1e-10);
+        Assert.Equal(0.0, s.StdDev, 1e-10);
+    }
+
+    [Fact]
+    public void Sdchannel_IsHot_TurnsTrueAfterWarmup()
+    {
+        var s = new Sdchannel(5, 2.0);
+
+        for (int i = 0; i < 4; i++)
+        {
+            s.Update(new TValue(DateTime.UtcNow, 100 + i));
+            Assert.False(s.IsHot);
+        }
+
+        s.Update(new TValue(DateTime.UtcNow, 200));
+        Assert.True(s.IsHot);
+    }
+
+    [Fact]
+    public void Sdchannel_IsNewFalse_RebuildsState()
+    {
+        var s = new Sdchannel(10, 2.0);
+        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);
+            s.Update(remembered, isNew: true);
+        }
+
+        double mid = s.Last.Value;
+        double up = s.Upper.Value;
+        double lo = s.Lower.Value;
+        double slope = s.Slope;
+        double stdDev = s.StdDev;
+
+        // Apply corrections
+        for (int i = 0; i < 5; i++)
+        {
+            var bar = gbm.Next(isNew: false);
+            s.Update(new TValue(bar.Time, bar.Close), isNew: false);
+        }
+
+        // Restore with remembered value
+        s.Update(remembered, isNew: false);
+
+        Assert.Equal(mid, s.Last.Value, 1e-6);
+        Assert.Equal(up, s.Upper.Value, 1e-6);
+        Assert.Equal(lo, s.Lower.Value, 1e-6);
+        Assert.Equal(slope, s.Slope, 1e-6);
+        Assert.Equal(stdDev, s.StdDev, 1e-6);
+    }
+
+    [Fact]
+    public void Sdchannel_NaN_UsesLastValid()
+    {
+        var s = new Sdchannel(10, 2.0);
+
+        s.Update(new TValue(DateTime.UtcNow, 100));
+        s.Update(new TValue(DateTime.UtcNow, 105));
+
+        var result = s.Update(new TValue(DateTime.UtcNow, double.NaN));
+        Assert.True(double.IsFinite(result.Value));
+        Assert.True(double.IsFinite(s.Upper.Value));
+        Assert.True(double.IsFinite(s.Lower.Value));
+
+        var result2 = s.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity));
+        Assert.True(double.IsFinite(result2.Value));
+    }
+
+    [Fact]
+    public void Sdchannel_Reset_Clears()
+    {
+        var s = new Sdchannel(10, 2.0);
+        s.Update(new TValue(DateTime.UtcNow, 100));
+        s.Update(new TValue(DateTime.UtcNow, 110));
+        s.Update(new TValue(DateTime.UtcNow, 120));
+
+        s.Reset();
+
+        Assert.Equal(0, s.Last.Value);
+        Assert.Equal(0, s.Upper.Value);
+        Assert.Equal(0, s.Lower.Value);
+        Assert.Equal(0, s.Slope);
+        Assert.Equal(0, s.StdDev);
+        Assert.False(s.IsHot);
+
+        s.Update(new TValue(DateTime.UtcNow, 50));
+        Assert.NotEqual(0, s.Last.Value);
+    }
+
+    [Fact]
+    public void Sdchannel_BatchVsStreaming_Match()
+    {
+        var sStream = new Sdchannel(20, 2.0);
+        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));
+            sStream.Update(series.Last, isNew: true);
+        }
+
+        double expectedMid = sStream.Last.Value;
+        double expectedUp = sStream.Upper.Value;
+        double expectedLo = sStream.Lower.Value;
+
+        var (midBatch, upBatch, loBatch) = Sdchannel.Batch(series, 20, 2.0);
+
+        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 Sdchannel_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>(() => Sdchannel.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Sdchannel.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Sdchannel.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 10, 0.0));
+        Assert.Throws<ArgumentException>(() => Sdchannel.Batch(source.AsSpan(), smallOut.AsSpan(), upper.AsSpan(), lower.AsSpan(), 2));
+    }
+
+    [Fact]
+    public void Sdchannel_SpanBatch_ComputesCorrectly()
+    {
+        double[] source = [100, 110, 100, 110, 100];
+        double[] middle = new double[5];
+        double[] upper = new double[5];
+        double[] lower = new double[5];
+
+        Sdchannel.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 3, 2.0);
+
+        // First value: regression = 100, stdDev = 0
+        Assert.Equal(100.0, middle[0], 1e-10);
+        Assert.Equal(100.0, upper[0], 1e-10);
+        Assert.Equal(100.0, lower[0], 1e-10);
+
+        // When stdDev > 0, bands should be symmetric around middle
+        for (int i = 0; i < 5; i++)
+        {
+            double upperDist = upper[i] - middle[i];
+            double lowerDist = middle[i] - lower[i];
+            Assert.Equal(upperDist, lowerDist, 1e-10);
+        }
+    }
+
+    [Fact]
+    public void Sdchannel_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) = Sdchannel.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 Sdchannel_Event_Publishes()
+    {
+        var src = new TSeries();
+        var s = new Sdchannel(src, 2);
+        bool fired = false;
+        s.Pub += (object? sender, in TValueEventArgs args) => fired = true;
+
+        src.Add(new TValue(DateTime.UtcNow, 100));
+        Assert.True(fired);
+    }
+
+    [Fact]
+    public void Sdchannel_LongSeriesStability()
+    {
+        var s = new Sdchannel(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);
+            s.Update(new TValue(bar.Time, bar.Close));
+
+            Assert.True(double.IsFinite(s.Last.Value), $"Middle finite at {i}");
+            Assert.True(double.IsFinite(s.Upper.Value), $"Upper finite at {i}");
+            Assert.True(double.IsFinite(s.Lower.Value), $"Lower finite at {i}");
+            Assert.True(double.IsFinite(s.Slope), $"Slope finite at {i}");
+            Assert.True(double.IsFinite(s.StdDev), $"StdDev finite at {i}");
+        }
+    }
+
+    [Fact]
+    public void Sdchannel_SlidingWindow_PeriodRespected()
+    {
+        var s = new Sdchannel(3, 2.0);
+
+        // Feed 5 values: 100, 200, 300, 400, 500
+        s.Update(new TValue(DateTime.UtcNow, 100));
+        s.Update(new TValue(DateTime.UtcNow, 200));
+        s.Update(new TValue(DateTime.UtcNow, 300));
+        s.Update(new TValue(DateTime.UtcNow, 400));
+        s.Update(new TValue(DateTime.UtcNow, 500));
+
+        // Window should now contain: 300, 400, 500
+        // Perfect linear trend with slope = 100
+        Assert.Equal(500.0, s.Last.Value, 1e-10);
+        Assert.Equal(100.0, s.Slope, 1e-10);
+        Assert.Equal(0.0, s.StdDev, 1e-10);
+    }
+}
@@ -0,0 +1,546 @@
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public sealed class SdchannelValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public SdchannelValidationTests(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_ThreePoints()
+    {
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        // Points: (0,100), (1,120), (2,110)
+        series.Add(new TValue(t0, 100));
+        series.Add(new TValue(t0.AddMinutes(1), 120));
+        series.Add(new TValue(t0.AddMinutes(2), 110));
+
+        var ind = new Sdchannel(10, 1.0);
+
+        // Bar 0: regression = 100, slope = 0, stdDev = 0
+        ind.Update(series[0]);
+        Assert.Equal(100.0, ind.Last.Value, 1e-10);
+        Assert.Equal(0.0, ind.Slope, 1e-10);
+        Assert.Equal(0.0, ind.StdDev, 1e-10);
+
+        // Bar 1: Two points (100, 120 at x=0,1)
+        // Perfect line through points: y = 100 + 20*x
+        // Regression at x=1 = 120
+        ind.Update(series[1]);
+        Assert.Equal(120.0, ind.Last.Value, 1e-10);
+        Assert.Equal(20.0, ind.Slope, 1e-10);
+        Assert.Equal(0.0, ind.StdDev, 1e-10);
+
+        // Bar 2: Linear regression of (100, 120, 110)
+        // x: 0,1,2  y: 100,120,110
+        // sumX=3, sumX2=5, sumY=330, sumXY=0*100+1*120+2*110=340
+        // denom = 3*5 - 3*3 = 6
+        // slope = (3*340 - 3*330) / 6 = (1020-990)/6 = 5
+        // intercept = (330 - 5*3) / 3 = 315/3 = 105
+        // Predicted: y(0)=105, y(1)=110, y(2)=115
+        // Residuals: 100-105=-5, 120-110=10, 110-115=-5
+        // StdDev = sqrt((25+100+25)/3) = sqrt(50)
+        ind.Update(series[2]);
+        Assert.Equal(115.0, ind.Last.Value, 1e-10);
+        Assert.Equal(5.0, ind.Slope, 1e-10);
+
+        double expectedStdDev = Math.Sqrt(50.0);
+        Assert.Equal(expectedStdDev, ind.StdDev, 1e-10);
+
+        _output.WriteLine("Sdchannel manual calculation validated");
+    }
+
+    [Fact]
+    public void Validate_LinearTrend_ZeroResiduals()
+    {
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        // Perfect linear trend: 100, 110, 120, 130, 140
+        for (int i = 0; i < 5; i++)
+        {
+            series.Add(new TValue(t0.AddMinutes(i), 100 + i * 10));
+        }
+
+        var ind = new Sdchannel(5, 2.0);
+        foreach (var tv in series)
+        {
+            ind.Update(tv);
+        }
+
+        // Perfect linear fit: slope = 10, no residuals
+        Assert.Equal(140.0, ind.Last.Value, 1e-10);
+        Assert.Equal(10.0, ind.Slope, 1e-10);
+        Assert.Equal(0.0, ind.StdDev, 1e-10);
+        Assert.Equal(140.0, ind.Upper.Value, 1e-10);
+        Assert.Equal(140.0, ind.Lower.Value, 1e-10);
+
+        _output.WriteLine("Sdchannel linear trend validated");
+    }
+
+    [Fact]
+    public void Validate_ConstantValues_ZeroResiduals()
+    {
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        // Constant values: 100, 100, 100, 100, 100
+        for (int i = 0; i < 5; i++)
+        {
+            series.Add(new TValue(t0.AddMinutes(i), 100));
+        }
+
+        var ind = new Sdchannel(5, 2.0);
+        foreach (var tv in series)
+        {
+            ind.Update(tv);
+        }
+
+        // Constant: slope = 0, no residuals
+        Assert.Equal(100.0, ind.Last.Value, 1e-10);
+        Assert.Equal(0.0, ind.Slope, 1e-10);
+        Assert.Equal(0.0, ind.StdDev, 1e-10);
+
+        _output.WriteLine("Sdchannel constant values validated");
+    }
+
+    [Fact]
+    public void Validate_AllModes_Consistency()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double[] multipliers = { 1.0, 2.0, 3.0 };
+
+        foreach (int period in periods)
+        {
+            foreach (double multiplier in multipliers)
+            {
+                // Batch (instance)
+                var inst = new Sdchannel(period, multiplier);
+                var (bMid, bUp, bLo) = inst.Update(_testData.Data);
+
+                // Static batch
+                var (sMid, sUp, sLo) = Sdchannel.Batch(_testData.Data, period, multiplier);
+
+                ValidationHelper.VerifySeriesEqual(bMid, sMid);
+                ValidationHelper.VerifySeriesEqual(bUp, sUp);
+                ValidationHelper.VerifySeriesEqual(bLo, sLo);
+
+                // Streaming
+                var streaming = new Sdchannel(period, multiplier);
+                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];
+                Sdchannel.Batch(source.AsSpan(), spanMid.AsSpan(), spanUp.AsSpan(), spanLo.AsSpan(), period, multiplier);
+
+                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("Sdchannel mode consistency validated (batch/stream/span)");
+    }
+
+    [Fact]
+    public void Validate_EventingMode_MatchesBatch()
+    {
+        const int period = 20;
+        const double multiplier = 2.0;
+
+        var pub = new TSeries();
+        var evtInd = new Sdchannel(pub, period, multiplier);
+        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) = Sdchannel.Batch(_testData.Data, period, multiplier);
+
+        ValidationHelper.VerifySeriesEqual(bMid, evtMid);
+        ValidationHelper.VerifySeriesEqual(bUp, evtUp);
+        ValidationHelper.VerifySeriesEqual(bLo, evtLo);
+
+        _output.WriteLine("Sdchannel eventing mode validated");
+    }
+
+    [Fact]
+    public void Validate_Calculate_ReturnsHotIndicator()
+    {
+        const int period = 15;
+        const double multiplier = 2.5;
+
+        var ((mid, up, lo), ind) = Sdchannel.Calculate(_testData.Data, period, multiplier);
+
+        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("Sdchannel Calculate validated");
+    }
+
+    [Fact]
+    public void Validate_Prime_MatchesBatch()
+    {
+        const int period = 25;
+        const double multiplier = 1.5;
+
+        var (bMid, bUp, bLo) = Sdchannel.Batch(_testData.Data, period, multiplier);
+
+        var primed = new Sdchannel(period, multiplier);
+        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("Sdchannel Prime validated against batch");
+    }
+
+    [Fact]
+    public void Validate_LargeDataset_FiniteOutputs()
+    {
+        var (mid, up, lo) = Sdchannel.Batch(_testData.Data, 50, 2.0);
+
+        ValidationHelper.VerifyAllFinite(mid, startIndex: 0);
+        ValidationHelper.VerifyAllFinite(up, startIndex: 0);
+        ValidationHelper.VerifyAllFinite(lo, startIndex: 0);
+
+        // Upper >= Middle >= Lower always
+        for (int i = 0; i < mid.Count; i++)
+        {
+            Assert.True(up[i].Value >= mid[i].Value, $"Upper >= Middle at {i}");
+            Assert.True(lo[i].Value <= mid[i].Value, $"Lower <= Middle at {i}");
+        }
+
+        _output.WriteLine("Sdchannel large dataset validated");
+    }
+
+    [Fact]
+    public void Validate_BandSymmetry_AllBars()
+    {
+        var ind = new Sdchannel(20, 2.0);
+        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("Sdchannel band symmetry validated for all bars");
+    }
+
+    [Fact]
+    public void Validate_MultiplierScaling()
+    {
+        double[] multipliers = { 1.0, 2.0, 3.0, 4.0 };
+        double[] widths = new double[multipliers.Length];
+
+        for (int i = 0; i < multipliers.Length; i++)
+        {
+            var ind = new Sdchannel(20, multipliers[i]);
+            foreach (var tv in _testData.Data)
+            {
+                ind.Update(tv);
+            }
+            widths[i] = ind.Upper.Value - ind.Lower.Value;
+        }
+
+        // Widths should scale linearly with multiplier
+        double baseWidth = widths[0];
+        for (int i = 1; i < multipliers.Length; i++)
+        {
+            double expected = baseWidth * multipliers[i];
+            Assert.Equal(expected, widths[i], 1e-9);
+        }
+
+        _output.WriteLine("Sdchannel multiplier scaling validated");
+    }
+
+    [Fact]
+    public void Validate_PeriodEffect_SmoothingAndSlope()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double[] slopes = new double[periods.Length];
+        double[] middles = new double[periods.Length];
+
+        for (int i = 0; i < periods.Length; i++)
+        {
+            var ind = new Sdchannel(periods[i], 2.0);
+            foreach (var tv in _testData.Data)
+            {
+                ind.Update(tv);
+            }
+            slopes[i] = ind.Slope;
+            middles[i] = ind.Last.Value;
+        }
+
+        // All should produce finite values
+        foreach (var s in slopes)
+        {
+            Assert.True(double.IsFinite(s));
+        }
+        foreach (var m in middles)
+        {
+            Assert.True(double.IsFinite(m));
+        }
+
+        _output.WriteLine("Sdchannel period effect validated");
+    }
+
+    [Fact]
+    public void Validate_StateRestoration_Iterative()
+    {
+        var ind = new Sdchannel(15, 2.5);
+        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;
+        double slopeBefore = ind.Slope;
+        double stdDevBefore = ind.StdDev;
+
+        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);
+        Assert.Equal(slopeBefore, ind.Slope, 1e-6);
+        Assert.Equal(stdDevBefore, ind.StdDev, 1e-6);
+
+        _output.WriteLine("Sdchannel state restoration validated");
+    }
+
+    [Fact]
+    public void Validate_BandWidthFormula()
+    {
+        // Band width = 2 * multiplier * stdDev
+        var ind = new Sdchannel(20, 3.0);
+
+        foreach (var tv in _testData.Data)
+        {
+            ind.Update(tv);
+
+            double expectedWidth = 2 * 3.0 * ind.StdDev;
+            double actualWidth = ind.Upper.Value - ind.Lower.Value;
+            Assert.Equal(expectedWidth, actualWidth, 1e-10);
+        }
+
+        _output.WriteLine("Sdchannel band width formula validated");
+    }
+
+    [Fact]
+    public void Validate_SlopeDirection()
+    {
+        // Test uptrend detection
+        var uptrend = new TSeries();
+        var t0 = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            uptrend.Add(new TValue(t0.AddMinutes(i), 100 + i * 2 + (i % 3))); // Noisy uptrend
+        }
+
+        var indUp = new Sdchannel(10, 2.0);
+        foreach (var tv in uptrend)
+        {
+            indUp.Update(tv);
+        }
+        Assert.True(indUp.Slope > 0, "Uptrend should have positive slope");
+
+        // Test downtrend detection
+        var downtrend = new TSeries();
+        for (int i = 0; i < 20; i++)
+        {
+            downtrend.Add(new TValue(t0.AddMinutes(i), 200 - i * 2 + (i % 3))); // Noisy downtrend
+        }
+
+        var indDown = new Sdchannel(10, 2.0);
+        foreach (var tv in downtrend)
+        {
+            indDown.Update(tv);
+        }
+        Assert.True(indDown.Slope < 0, "Downtrend should have negative slope");
+
+        _output.WriteLine("Sdchannel slope direction validated");
+    }
+
+    [Fact]
+    public void Validate_SlidingWindow_Correctness()
+    {
+        const int period = 5;
+        var ind = new Sdchannel(period, 2.0);
+
+        // Feed specific values
+        double[] values = { 100, 110, 120, 130, 140, 150, 160, 170 };
+        var t0 = DateTime.UtcNow;
+
+        foreach (double v in values)
+        {
+            ind.Update(new TValue(t0, v));
+            t0 = t0.AddMinutes(1);
+        }
+
+        // Window should contain: 140, 150, 160, 170, 180 -> wait, we only have 140,150,160,170
+        // Actually: 140, 150, 160, 170 at positions 0,1,2,3 (newest is 170)
+        // No wait, period=5, and we have 8 values. Window = last 5: 120,130,140,150,160,170 - no
+        // Let me recalculate: values = 100,110,120,130,140,150,160,170 (8 values)
+        // After all updates, window has last 5: 130,140,150,160,170
+        // Linear regression of 130,140,150,160,170 at x=0,1,2,3,4
+        // Perfect linear fit: slope = 10, intercept = 130
+        // regression at x=4 = 130 + 10*4 = 170
+        Assert.Equal(170.0, ind.Last.Value, 1e-10);
+        Assert.Equal(10.0, ind.Slope, 1e-10);
+        Assert.Equal(0.0, ind.StdDev, 1e-10); // Perfect linear fit
+
+        _output.WriteLine("Sdchannel sliding window validated");
+    }
+
+    [Fact]
+    public void Validate_Residuals_NonLinearData()
+    {
+        // Test with data that doesn't fit a perfect line
+        var ind = new Sdchannel(4, 1.0);
+        var t0 = DateTime.UtcNow;
+
+        // Values: 100, 120, 100, 120 (oscillating)
+        ind.Update(new TValue(t0, 100));
+        ind.Update(new TValue(t0.AddMinutes(1), 120));
+        ind.Update(new TValue(t0.AddMinutes(2), 100));
+        ind.Update(new TValue(t0.AddMinutes(3), 120));
+
+        // These values don't fit a line well, so stdDev should be significant
+        Assert.True(ind.StdDev > 5, "Oscillating data should have significant residuals");
+
+        // Bands should be wider than regression value
+        Assert.True(ind.Upper.Value > ind.Last.Value, "Upper > Middle with residuals");
+        Assert.True(ind.Lower.Value < ind.Last.Value, "Lower < Middle with residuals");
+
+        _output.WriteLine("Sdchannel residuals for non-linear data validated");
+    }
+
+    [Fact]
+    public void Validate_StdDev_Formula()
+    {
+        // Verify stdDev calculation: sqrt(sum(residual^2)/n)
+        var ind = new Sdchannel(5, 2.0);
+        var t0 = DateTime.UtcNow;
+
+        // Known values for manual calculation
+        double[] values = { 100, 105, 98, 107, 102 };
+        foreach (double v in values)
+        {
+            ind.Update(new TValue(t0, v));
+            t0 = t0.AddMinutes(1);
+        }
+
+        // Calculate expected regression manually
+        // x: 0,1,2,3,4  y: 100,105,98,107,102
+        // sumX = 10, sumX2 = 30, sumY = 512, sumXY = 1053
+        // denom = 5*30 - 10*10 = 50
+        // slope = (5*1053 - 10*512) / 50 = (5265-5120)/50 = 2.9
+        // intercept = (512 - 2.9*10) / 5 = (512-29)/5 = 96.6
+        // predicted: 96.6, 99.5, 102.4, 105.3, 108.2
+        // residuals: 3.4, 5.5, -4.4, 1.7, -6.2
+        // sum(r^2) = 11.56 + 30.25 + 19.36 + 2.89 + 38.44 = 102.5
+        // stdDev = sqrt(102.5/5) = sqrt(20.5) ≈ 4.53
+
+        // Slope should be positive (trend is slightly upward)
+        Assert.True(ind.Slope > 0 && ind.Slope < 5, $"Slope={ind.Slope} should be small positive");
+        // StdDev should be non-trivial since data doesn't fit perfectly
+        Assert.True(ind.StdDev > 0 && ind.StdDev < 10, $"StdDev={ind.StdDev} should be positive");
+
+        _output.WriteLine($"Sdchannel stdDev formula validated: Slope={ind.Slope:F4}, StdDev={ind.StdDev:F4}");
+    }
+}
@@ -0,0 +1,442 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// SDCHANNEL: Standard Deviation Channel
+/// Linear regression centerline with bands at ±multiplier × standard deviation of residuals.
+/// </summary>
+/// <remarks>
+/// The Standard Deviation Channel plots a linear regression line with parallel bands
+/// positioned at a specified number of standard deviations of the residuals above and below.
+///
+/// Calculation:
+/// 1. Compute linear regression line: y = mx + b using least squares
+/// 2. Calculate residuals: residual_i = y_i - predicted_i
+/// 3. Compute standard deviation of residuals: σ = √(Σ(residual²) / n)
+/// 4. Upper = regression + multiplier × σ
+/// 5. Lower = regression - multiplier × σ
+///
+/// Key characteristics:
+/// - Middle line is the linear regression endpoint (LSMA)
+/// - Bands measure dispersion around the regression line
+/// - Wider bands indicate more noise/volatility around the trend
+/// - Price touching bands suggests deviation from trend
+///
+/// Sources:
+///     https://www.investopedia.com/terms/l/linearregressionindicator.asp
+///     https://school.stockcharts.com/doku.php?id=technical_indicators:linear_regression_indicator
+/// </remarks>
+[SkipLocalsInit]
+public sealed class Sdchannel : ITValuePublisher
+{
+    private readonly int _period;
+    private readonly double _multiplier;
+
+    // Precomputed constants for linear regression
+    private readonly double _sumX;      // sum of x indices: 0 + 1 + ... + (n-1)
+    private readonly double _denominator; // n * sumX2 - sumX²
+
+    // Ring buffer for values
+    private readonly double[] _buffer;
+    private double[]? _p_buffer;
+
+    [StructLayout(LayoutKind.Auto)]
+    private record struct State(
+        int Head,
+        int Count,
+        double LastValid,
+        double Slope,
+        double StdDev,
+        bool IsHot);
+
+    private State _state;
+    private State _p_state;
+
+    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;
+
+    /// <summary>
+    /// The slope of the linear regression line
+    /// </summary>
+    public double Slope => _state.Slope;
+
+    /// <summary>
+    /// The standard deviation of residuals
+    /// </summary>
+    public double StdDev => _state.StdDev;
+
+    public event TValuePublishedHandler? Pub;
+
+    /// <param name="period">Lookback period for regression (default 20, must be > 1)</param>
+    /// <param name="multiplier">Standard deviation multiplier for bands (default 2.0, must be > 0)</param>
+    public Sdchannel(int period = 20, double multiplier = 2.0)
+    {
+        if (period <= 1)
+            throw new ArgumentOutOfRangeException(nameof(period), "Period must be greater than 1.");
+        if (multiplier <= 0)
+            throw new ArgumentOutOfRangeException(nameof(multiplier), "Multiplier must be greater than 0.");
+
+        _period = period;
+        _multiplier = multiplier;
+        _buffer = new double[period];
+        _p_buffer = new double[period];
+        WarmupPeriod = period;
+        Name = $"Sdchannel({period},{multiplier:F1})";
+        _valueHandler = HandleValue;
+
+        // Precompute constants
+        // sumX = 0 + 1 + ... + (n-1) = n(n-1)/2
+        _sumX = 0.5 * period * (period - 1);
+        // sumX2 = 0² + 1² + ... + (n-1)² = (n-1)n(2n-1)/6
+        double sumX2 = (period - 1.0) * period * (2.0 * period - 1.0) / 6.0;
+        // denominator = n * sumX2 - sumX²
+        _denominator = period * sumX2 - _sumX * _sumX;
+
+        Reset();
+    }
+
+    public Sdchannel(TSeries source, int period = 20, double multiplier = 2.0) : this(period, multiplier)
+    {
+        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, double.NaN, 0, 0, false);
+        _p_state = _state;
+        Array.Fill(_buffer, 0.0);
+        _p_buffer = (double[])_buffer.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 double.IsFinite(_state.LastValid) ? _state.LastValid : 0.0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TValue Update(TValue input, bool isNew = true)
+    {
+        if (isNew)
+        {
+            _p_state = _state;
+            Array.Copy(_buffer, _p_buffer!, _period);
+        }
+        else
+        {
+            _state = _p_state;
+            Array.Copy(_p_buffer!, _buffer, _period);
+        }
+
+        double value = GetValid(input.Value, isNew);
+
+        // Add to ring buffer
+        int count = _state.Count;
+        int head = _state.Head;
+
+        if (count < _period)
+            count++;
+
+        _buffer[head] = value;
+        int newHead = (head + 1) % _period;
+
+        if (isNew)
+            _state = _state with { Head = newHead, Count = count };
+
+        // Calculate linear regression and std dev of residuals
+        if (count <= 1)
+        {
+            Last = new TValue(input.Time, value);
+            Upper = new TValue(input.Time, value);
+            Lower = new TValue(input.Time, value);
+            _state = _state with { Slope = 0, StdDev = 0 };
+            PubEvent(Last, isNew);
+            return Last;
+        }
+
+        // Build span of values in chronological order (oldest to newest)
+        Span<double> values = stackalloc double[count];
+        int readHead = (newHead - count + _period) % _period;
+        for (int i = 0; i < count; i++)
+        {
+            values[i] = _buffer[(readHead + i) % _period];
+        }
+
+        // Calculate sums for linear regression
+        double sumY = 0;
+        double sumXY = 0;
+
+        for (int i = 0; i < count; i++)
+        {
+            sumY += values[i];
+            sumXY += i * values[i];
+        }
+
+        double n = count;
+        double sx = _sumX;
+        double denom = _denominator;
+
+        // Adjust for partial window during warmup
+        if (count < _period)
+        {
+            sx = 0.5 * n * (n - 1);
+            double sx2 = (n - 1.0) * n * (2.0 * n - 1.0) / 6.0;
+            denom = n * sx2 - sx * sx;
+        }
+
+        double slope, intercept, regression;
+
+        if (Math.Abs(denom) < 1e-10)
+        {
+            slope = 0;
+            intercept = sumY / n;
+            regression = intercept;
+        }
+        else
+        {
+            slope = (n * sumXY - sx * sumY) / denom;
+            intercept = (sumY - slope * sx) / n;
+            // Regression value at current point (x = count - 1)
+            regression = Math.FusedMultiplyAdd(slope, count - 1, intercept);
+        }
+
+        // Calculate standard deviation of residuals
+        double sumResiduals2 = 0;
+        for (int i = 0; i < count; i++)
+        {
+            double predicted = Math.FusedMultiplyAdd(slope, i, intercept);
+            double residual = values[i] - predicted;
+            sumResiduals2 = Math.FusedMultiplyAdd(residual, residual, sumResiduals2);
+        }
+
+        double stdDev = Math.Sqrt(sumResiduals2 / n);
+        double band = _multiplier * stdDev;
+
+        if (!_state.IsHot && count >= WarmupPeriod)
+            _state = _state with { IsHot = true };
+
+        _state = _state with { Slope = slope, StdDev = stdDev };
+
+        Last = new TValue(input.Time, regression);
+        Upper = new TValue(input.Time, regression + band);
+        Lower = new TValue(input.Time, regression - band);
+
+        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, _multiplier);
+
+        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));
+    }
+
+    public void Prime(TSeries source)
+    {
+        Reset();
+
+        if (source.Count == 0)
+            return;
+
+        for (int i = 0; i < source.Count; i++)
+        {
+            Update(source[i], isNew: true);
+        }
+    }
+
+    /// <summary>
+    /// Batch calculation using spans.
+    /// </summary>
+    public static void Batch(
+        ReadOnlySpan<double> source,
+        Span<double> middle,
+        Span<double> upper,
+        Span<double> lower,
+        int period,
+        double multiplier = 2.0)
+    {
+        if (period <= 1)
+            throw new ArgumentOutOfRangeException(nameof(period), "Period must be greater than 1.");
+        if (multiplier <= 0)
+            throw new ArgumentOutOfRangeException(nameof(multiplier), "Multiplier must be greater than 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;
+
+        // Precompute constants for full period
+        double sumXFull = 0.5 * period * (period - 1);
+        double sumX2Full = (period - 1.0) * period * (2.0 * period - 1.0) / 6.0;
+        double denomFull = period * sumX2Full - sumXFull * sumXFull;
+
+        for (int i = 0; i < len; i++)
+        {
+            int count = Math.Min(i + 1, period);
+            int start = i - count + 1;
+
+            if (count <= 1)
+            {
+                middle[i] = source[i];
+                upper[i] = source[i];
+                lower[i] = source[i];
+                continue;
+            }
+
+            // Calculate sums for linear regression
+            double sumY = 0;
+            double sumXY = 0;
+
+            for (int j = 0; j < count; j++)
+            {
+                double y = source[start + j];
+                sumY += y;
+                sumXY += j * y;
+            }
+
+            double n = count;
+            double sx, denom;
+
+            if (count < period)
+            {
+                sx = 0.5 * n * (n - 1);
+                double sx2 = (n - 1.0) * n * (2.0 * n - 1.0) / 6.0;
+                denom = n * sx2 - sx * sx;
+            }
+            else
+            {
+                sx = sumXFull;
+                denom = denomFull;
+            }
+
+            double slope, intercept, regression;
+
+            if (Math.Abs(denom) < 1e-10)
+            {
+                slope = 0;
+                intercept = sumY / n;
+                regression = intercept;
+            }
+            else
+            {
+                slope = (n * sumXY - sx * sumY) / denom;
+                intercept = (sumY - slope * sx) / n;
+                regression = Math.FusedMultiplyAdd(slope, count - 1, intercept);
+            }
+
+            // Calculate standard deviation of residuals
+            double sumResiduals2 = 0;
+            for (int j = 0; j < count; j++)
+            {
+                double predicted = Math.FusedMultiplyAdd(slope, j, intercept);
+                double residual = source[start + j] - predicted;
+                sumResiduals2 = Math.FusedMultiplyAdd(residual, residual, sumResiduals2);
+            }
+
+            double stdDev = Math.Sqrt(sumResiduals2 / n);
+            double band = multiplier * stdDev;
+
+            middle[i] = regression;
+            upper[i] = regression + band;
+            lower[i] = regression - band;
+        }
+    }
+
+    public static (TSeries Middle, TSeries Upper, TSeries Lower) Batch(TSeries source, int period = 20, double multiplier = 2.0)
+    {
+        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, multiplier);
+
+        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));
+    }
+
+    public static ((TSeries Middle, TSeries Upper, TSeries Lower) Results, Sdchannel Indicator) Calculate(TSeries source, int period = 20, double multiplier = 2.0)
+    {
+        var indicator = new Sdchannel(source, period, multiplier);
+        var results = indicator.Update(source);
+        return (results, indicator);
+    }
+}
@@ -1,140 +1,188 @@
 # SDCHANNEL: Standard Deviation Channel

-## Overview and Purpose
+> "The regression line tells you where price should be. The standard deviation tells you how wrong the market usually is."

-Standard Deviation Channels are a statistical channel indicator that combines linear regression analysis with standard deviation measurements to create dynamic support and resistance levels. The indicator uses a linear regression line as the central trend line and plots parallel lines at specified standard deviation distances above and below this regression line. The standard deviation is calculated from the residuals (deviations of actual prices from the regression line), providing a measure of how much prices typically deviate from the underlying linear trend.
+Standard Deviation Channel (SDCHANNEL) plots a linear regression line through price data with parallel bands positioned at a specified number of standard deviations of the residuals above and below. Unlike Bollinger Bands which measure deviation from a moving average, SDCHANNEL measures deviation from the best-fit trend line—capturing how much price wanders from its underlying trajectory rather than from its simple average.

-This approach creates a channel where the central line represents the statistical best-fit trend through recent price data, while the upper and lower boundaries indicate statistically significant price levels based on how much prices typically deviate from this trend. This combination makes Standard Deviation Channels particularly effective for identifying trend continuations, potential reversal points, and optimal entry/exit levels in trending markets.
+## Historical Context

-## Core Concepts
+Linear regression channels emerged from statistical methods applied to financial markets in the 1980s and 1990s. Gilbert Raff popularized "Raff Regression Channels" which use similar concepts. The standard deviation of residuals approach provides a statistically meaningful measure of dispersion around the trend.

-* **Linear regression foundation:** Uses least-squares regression to determine the most statistically probable trend direction
-* **Residual-based boundaries:** Channel width adapts automatically based on how much prices deviate from the regression line
-* **Statistical significance:** Channel breaks often indicate statistically meaningful price movements beyond normal trend deviations
-* **Trend-relative volatility:** Measures price volatility specifically relative to the linear trend, not absolute price levels
-* **Dynamic adaptation:** Both trend direction and channel width adjust automatically as new price data becomes available
+The key insight: a moving average treats all recent prices equally, while linear regression fits a line that best explains the trend. The residuals (differences between actual and predicted prices) measure how much price deviates from this trend. When prices consistently touch the upper band, the trend is accelerating; when they hug the lower band, momentum is fading.

-Standard Deviation Channels differ from other channel indicators by measuring volatility relative to a linear trend. While Bollinger Bands use standard deviation around a moving average, Standard Deviation Channels calculate the standard deviation of residuals from a regression line, providing a more precise measure of trend-relative price behavior.
+Most charting platforms compute linear regression naively with O(n) operations per bar. This implementation precomputes constants and uses FMA operations for efficiency.

-## Common Settings and Parameters
+## Architecture & Physics

-| Parameter | Default | Function | When to Adjust |
-| ------ | ------ | ------ | ------ |
-| Period | 20 | Lookback window for regression and standard deviation calculations | Shorter (10-15) for more responsive channels; longer (30-50) for smoother, more stable trends |
-| Source | Close | Price data used for calculations | Rarely changed; could use HLC3 for more comprehensive price analysis |
-| Multiplier | 2.0 | Standard deviation multiplier for channel distance | Higher values (2.5-3.0) for wider channels with fewer false signals; lower values (1.5-1.8) for tighter channels with more trading opportunities |
+Standard Deviation Channels consist of three components: the linear regression line (middle), and upper/lower bands at ±multiplier × standard deviation of residuals.

-**Pro Tip:** For swing trading, use period = 25 with multiplier = 2.5 to capture intermediate-term trends while filtering out short-term noise. For day trading, period = 14 with multiplier = 2.0 provides more responsive signals. The regression line often acts as dynamic support in uptrends and resistance in downtrends, making it valuable for trend-following strategies.
+### 1. Linear Regression (Middle Band)

-## Calculation and Mathematical Foundation
+The best-fit line through the lookback window using ordinary least squares:

-**Simplified explanation:**
-Standard Deviation Channels calculate a linear regression line through recent price data to identify the trend, then measure how much prices typically deviate from this trend line. The channel boundaries are placed at a specified number of standard deviations above and below the regression line.
+$$
+y = mx + b
+$$

-**Technical formula:**
+where:

-```
-Linear Regression:
-slope = (n × Σ(xy) - Σ(x) × Σ(y)) / (n × Σ(x²) - (Σ(x))²)
-intercept = (Σ(y) - slope × Σ(x)) / n
-regression_line = slope × x + intercept
+$$
+m = \frac{n \sum xy - \sum x \sum y}{n \sum x^2 - (\sum x)^2}
+$$

-Standard Deviation of Residuals:
-residual[i] = actual_price[i] - predicted_price[i]
-variance = Σ(residual²) / n
-std_dev = √variance
+$$
+b = \frac{\sum y - m \sum x}{n}
+$$

-Channel Lines:
-upper_channel = regression_line + (multiplier × std_dev)
-lower_channel = regression_line - (multiplier × std_dev)
-```
+The middle band value is the regression line evaluated at the current bar (x = n-1).

-Where:
-* n = period length
-* x = time index (0, 1, 2, ..., n-1)
-* y = price values over the period
-* residual = difference between actual price and regression line value
-* multiplier = standard deviation multiplier (typically 2.0)
+### 2. Standard Deviation of Residuals

-> 🔍 **Technical Note:** This implementation calculates the standard deviation of residuals from the regression line, not the overall price standard deviation. This approach measures how much prices typically deviate from the linear trend, providing a more accurate representation of trend-relative volatility compared to methods that use price deviations from a simple mean.
+For each point, compute the residual (difference between actual and predicted):

-## Interpretation Details
+$$
+r_i = y_i - (m \cdot x_i + b)
+$$

-Standard Deviation Channels provide comprehensive trend and volatility analysis:
+The standard deviation of these residuals:

-* **Trend identification:** The regression line slope indicates trend direction and strength - steeper slopes suggest stronger directional momentum
-* **Channel breakouts:** Price breaking above the upper channel suggests strong bullish momentum; breaking below the lower channel indicates bearish pressure
-* **Mean reversion signals:** Price touching the channel boundaries often presents opportunities for trades back toward the regression line
-* **Volatility assessment:** Channel width provides insight into current trend-relative volatility - narrow channels suggest consistent price behavior around the trend
-* **Support and resistance:** The regression line frequently acts as dynamic support in uptrends and resistance in downtrends
-* **Entry timing:** Price near the lower channel in uptrends or upper channel in downtrends can provide favorable entry points
-* **Exit signals:** Channel breaks opposite to the main trend may signal trend exhaustion or reversal
-* **Statistical confidence:** The residual-based standard deviation provides statistical context for evaluating the significance of price movements relative to the trend
+$$
+\sigma = \sqrt{\frac{\sum_{i=0}^{n-1} r_i^2}{n}}
+$$
+
+Note: This uses population standard deviation (divide by n), not sample standard deviation (divide by n-1).
+
+### 3. Upper and Lower Bands
+
+Parallel lines at fixed distance from the regression line:
+
+$$
+U_t = R_t + k \cdot \sigma
+$$
+
+$$
+L_t = R_t - k \cdot \sigma
+$$
+
+where $R_t$ is the regression value at time $t$ and $k$ is the multiplier (typically 2.0).
+
+## Mathematical Foundation
+
+### Precomputed Constants
+
+For a fixed period $n$, several sums can be precomputed:
+
+$$
+\sum x = 0 + 1 + ... + (n-1) = \frac{n(n-1)}{2}
+$$
+
+$$
+\sum x^2 = 0^2 + 1^2 + ... + (n-1)^2 = \frac{(n-1)n(2n-1)}{6}
+$$
+
+$$
+\text{denom} = n \sum x^2 - (\sum x)^2
+$$
+
+This reduces per-bar computation to:
+
+1. Calculate $\sum y$ and $\sum xy$ over the window
+2. Compute slope and intercept using precomputed values
+3. Evaluate regression at current point
+4. Compute residuals and their standard deviation
+
+### Slope Interpretation
+
+The slope indicates trend direction and strength:
+
+- $m > 0$: Uptrend (higher slope = steeper ascent)
+- $m < 0$: Downtrend (lower slope = steeper descent)
+- $m \approx 0$: Sideways/consolidating market
+
+### Residual Properties
+
+By definition of least squares regression:
+
+- Sum of residuals = 0
+- Residuals are uncorrelated with x values
+- Points above and below the line balance out
+
+When $\sigma = 0$, all points lie exactly on the regression line (perfect linear trend).

 ## Performance Profile

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

-Standard Deviation Channel uses linear regression plus residual-based standard deviation:
+Per-bar cost for streaming update:

 | Operation | Count | Cost (cycles) | Subtotal |
 | :--- | :---: | :---: | :---: |
-| ADD/SUB | 8 | 1 | 8 |
-| MUL | 6 | 3 | 18 |
+| ADD/SUB | ~4n | 1 | 4n |
+| MUL | ~2n | 3 | 6n |
 | DIV | 4 | 15 | 60 |
 | SQRT | 1 | 15 | 15 |
-| **Total** | **19** | — | **~101 cycles** |
+| FMA | 2n | 4 | 8n |
+| **Total** | — | — | **~18n + 75 cycles** |

-**Breakdown:**
- Running sum updates (Σxy, Σx, Σy, Σx²): 4 ADD + 2 MUL = 10 cycles
- Slope calculation: 2 MUL + 2 SUB + 1 DIV = 23 cycles
- Intercept calculation: 1 MUL + 1 SUB + 1 DIV = 19 cycles
- Residual variance: 1 SUB + 1 MUL + 1 DIV = 19 cycles
- Std dev + bands: 1 SQRT + 1 MUL + 2 ADD = 21 cycles
+For period=20: ~435 cycles per bar. The algorithm is O(n) per bar due to the sum calculations over the window.

-**Note:** Identical to REGCHANNEL as both use linear regression with residual standard deviation.
+### Batch Mode (512 values, SIMD/FMA)

-### Complexity Analysis
+Linear regression has limited SIMD benefit due to sequential dependencies and the need to accumulate sums:

-| Mode | Complexity | Notes |
-| :--- | :---: | :--- |
-| Streaming | O(1) | Running sums with sliding window |
-| Batch | O(n) | Linear scan with running sums |
+| Operation | Scalar Ops | SIMD Benefit | Notes |
+| :--- | :---: | :---: | :--- |
+| Sum Y, Sum XY | O(n) | Partial | Reduction operations |
+| Residual calc | O(n) | 4-8× | Embarrassingly parallel |
+| StdDev | O(n) | Partial | Reduction at end |

-**Memory**: ~80 bytes (running sums for regression statistics)
+**Batch efficiency (512 bars, period=20):**

-### SIMD Analysis
-
-| Optimization | Applicable | Notes |
-| :--- | :---: | :--- |
-| AVX2 vectorization | Partial | Residual calculation vectorizable |
-| FMA | ✅ | `slope * x + intercept` pattern |
-| Batch parallelism | Partial | Sequential regression limits parallelization |
+| Mode | Cycles/bar | Total (512 bars) | Overhead |
+| :--- | :---: | :---: | :---: |
+| Scalar streaming | 435 | 222,720 | — |
+| SIMD residuals | ~380 | ~194,560 | — |
+| **Improvement** | **~13%** | **~28K saved** | — |

 ### Quality Metrics

 | Metric | Score | Notes |
 | :--- | :---: | :--- |
-| **Accuracy** | 9/10 | Least-squares optimal fit |
-| **Timeliness** | 6/10 | Lag from regression lookback |
-| **Overshoot** | 8/10 | Linear model constrains overshoot |
-| **Smoothness** | 8/10 | Regression line naturally smooth |
+| **Accuracy** | 10/10 | Exact least squares calculation |
+| **Timeliness** | 5/10 | Regression lags by nature—fits past data |
+| **Overshoot** | 8/10 | Bands based on residuals, not price velocity |
+| **Smoothness** | 7/10 | Regression line smooths noise; bands vary with residual dispersion |

-## Limitations and Considerations
+## Validation

-* **Lagging nature:** Based on historical data, the channel will lag during rapid trend changes or market reversals
-* **Linear assumption:** Assumes linear price relationships over the calculation period, which may not hold during complex market movements
-* **Period dependency:** Different period settings can produce significantly different channel orientations and interpretations
-* **False breakouts:** Not all channel breaks result in sustained moves; requires confirmation from other technical indicators
-* **Sideways markets:** Less effective during ranging or choppy conditions where no clear linear trend exists
-* **Residual distribution:** Assumes residuals follow normal distribution patterns around the regression line
-* **Parameter sensitivity:** Channel width and trend sensitivity highly dependent on multiplier and period settings
-* **Market condition adaptation:** May require parameter adjustments for different market volatility regimes
+| Library | Status | Notes |
+| :--- | :---: | :--- |
+| **TA-Lib** | N/A | No equivalent function |
+| **Skender** | N/A | No equivalent function |
+| **Tulip** | N/A | No equivalent function |
+| **Ooples** | N/A | No equivalent function |
+| **Manual** | ✅ | Verified against hand calculations |
+
+The indicator is validated against manual calculations of linear regression and standard deviation of residuals.
+
+## Common Pitfalls
+
+1. **Period Selection**: Short periods (5-10) make the regression overly sensitive to recent bars; long periods (50+) create substantial lag. Period 20 is common, matching roughly one month of daily data.
+
+2. **Multiplier Choice**: The default multiplier of 2.0 captures ~95% of residuals assuming normal distribution. Use 1.0 for tighter bands (~68%), 3.0 for wider bands (~99.7%).
+
+3. **Warmup Period**: The indicator requires at least 2 bars to compute a regression line. WarmupPeriod equals the period parameter. Before warmup, bands equal the input value.
+
+4. **Zero Standard Deviation**: When all points lie exactly on a line (perfect linear trend or constant values), $\sigma = 0$ and bands collapse to the regression line. This is mathematically correct but may confuse traders expecting separated bands.
+
+5. **Regression vs. Moving Average**: The regression line projects the trend, not the average. It can be above or below all recent prices if the trend is strong. Don't expect the middle band to pass through recent data.
+
+6. **O(n) Complexity**: Unlike EMA (O(1)) or SMA with ring buffer (O(1)), linear regression requires O(n) operations per bar. For period=100 on tick data, this adds up. Consider using longer timeframes or smaller periods for real-time applications.
+
+7. **Memory**: The ring buffer stores `period` doubles. For period=50, that's 400 bytes per instance. For 1,000 symbols: 400 KB—negligible but worth noting for embedded systems.

 ## References

-* Murphy, J. J. (1999). Technical Analysis of the Financial Markets. New York Institute of Finance.
-* Kaufman, P. J. (2013). Trading Systems and Methods (5th ed.). John Wiley & Sons.
-* Elder, A. (2014). The New Trading for a Living. John Wiley & Sons.
-* Achelis, S. B. (2001). Technical Analysis from A to Z. McGraw-Hill.
-* Bollinger, J. (2001). Bollinger on Bollinger Bands. McGraw-Hill.
+- Raff, G. (1991). "Trading the Regression Channel." *Technical Analysis of Stocks & Commodities*.
+- Bulkowski, T. (2005). *Encyclopedia of Chart Patterns*, 2nd ed. Wiley. (Chapter on Linear Regression)
+- Kaufman, P. J. (2013). *Trading Systems and Methods*, 5th ed. Wiley. (Linear Regression Indicators)