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 13:08:04 +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 RegchannelIndicatorTests
+{
+    [Fact]
+    public void Constructor_SetsDefaults()
+    {
+        var ind = new RegchannelIndicator();
+
+        Assert.Equal(20, ind.Period);
+        Assert.Equal(2.0, ind.Multiplier);
+        Assert.Equal(PriceType.Close, ind.SourceType);
+        Assert.True(ind.ShowColdValues);
+        Assert.Equal("Regchannel - Linear Regression Channel", ind.Name);
+        Assert.False(ind.SeparateWindow);
+        Assert.True(ind.OnBackGround);
+    }
+
+    [Fact]
+    public void MinHistoryDepths_EqualsPeriod()
+    {
+        var ind = new RegchannelIndicator { Period = 30 };
+        Assert.Equal(30, ind.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ShortName_ReflectsParameters()
+    {
+        var ind = new RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { Period = 10, Multiplier = 1.0 };
+        var ind2 = new RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { 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 RegchannelIndicator { Period = 10, Multiplier = 2.0, SourceType = PriceType.Close };
+        var indHigh = new RegchannelIndicator { 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 RegchannelIndicator { 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>
+/// Regchannel: Linear Regression 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 RegchannelIndicator : Indicator, IWatchlistIndicator
+{
+    [InputParameter("Period", sortIndex: 10, minimum: 2, maximum: 500, increment: 1, decimalPlaces: 0)]
+    public int Period { get; set; } = 20;
+
+    [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 Regchannel? _indicator;
+
+    public int MinHistoryDepths => Period;
+    public override string ShortName => $"Regchannel({Period},{Multiplier})";
+
+    public RegchannelIndicator()
+    {
+        Name = "Regchannel - Linear Regression Channel";
+        Description = "Linear regression channel with standard deviation bands";
+        SeparateWindow = false;
+        OnBackGround = true;
+    }
+
+    protected override void OnInit()
+    {
+        _indicator = new Regchannel(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,484 @@
+using System;
+using QuanTAlib;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class RegchannelTests
+{
+    private const int TestPeriod = 20;
+    private const double TestMultiplier = 2.0;
+
+    [Fact]
+    public void Constructor_ValidParameters_CreatesIndicator()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+
+        Assert.Equal($"Regchannel({TestPeriod},{TestMultiplier:F1})", ind.Name);
+        Assert.Equal(TestPeriod, ind.WarmupPeriod);
+        Assert.False(ind.IsHot);
+    }
+
+    [Fact]
+    public void Constructor_PeriodLessThan2_Throws()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Regchannel(1));
+    }
+
+    [Fact]
+    public void Constructor_ZeroMultiplier_Throws()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Regchannel(10, 0));
+    }
+
+    [Fact]
+    public void Constructor_NegativeMultiplier_Throws()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Regchannel(10, -1));
+    }
+
+    [Fact]
+    public void InitialState_AllDefaultValues()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+
+        Assert.Equal(default, ind.Last);
+        Assert.Equal(default, ind.Upper);
+        Assert.Equal(default, ind.Lower);
+        Assert.Equal(0, ind.Slope);
+        Assert.Equal(0, ind.StdDev);
+        Assert.False(ind.IsHot);
+    }
+
+    [Fact]
+    public void FirstValue_AllBandsEqualInput()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+        var now = DateTime.UtcNow;
+
+        ind.Update(new TValue(now, 100.0));
+
+        Assert.Equal(100.0, ind.Last.Value, 1e-10);
+        Assert.Equal(100.0, ind.Upper.Value, 1e-10);
+        Assert.Equal(100.0, ind.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void LinearData_ZeroStdDev()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        // Feed perfect linear data: y = 100 + i
+        for (int i = 0; i < 20; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+        }
+
+        // With perfect linear fit, stddev should be ~0
+        Assert.True(ind.StdDev < 1e-9, $"StdDev should be ~0 for linear data, got {ind.StdDev}");
+        Assert.Equal(ind.Last.Value, ind.Upper.Value, 1e-9);
+        Assert.Equal(ind.Last.Value, ind.Lower.Value, 1e-9);
+    }
+
+    [Fact]
+    public void LinearData_CorrectSlope()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        // Feed perfect linear data: y = 100 + 2*i (slope = 2)
+        for (int i = 0; i < 20; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + 2 * i));
+        }
+
+        // Slope should be 2
+        Assert.Equal(2.0, ind.Slope, 1e-9);
+    }
+
+    [Fact]
+    public void BandWidth_IncreasesWithVolatility()
+    {
+        var ind1 = new Regchannel(10, 2.0);
+        var ind2 = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        // Low volatility: close to linear
+        for (int i = 0; i < 20; i++)
+        {
+            ind1.Update(new TValue(now.AddMinutes(i), 100 + i + 0.1 * Math.Sin(i)));
+        }
+
+        // High volatility: large deviations from linear
+        for (int i = 0; i < 20; i++)
+        {
+            ind2.Update(new TValue(now.AddMinutes(i), 100 + i + 5 * Math.Sin(i)));
+        }
+
+        double width1 = ind1.Upper.Value - ind1.Lower.Value;
+        double width2 = ind2.Upper.Value - ind2.Lower.Value;
+
+        Assert.True(width2 > width1, $"High volatility width ({width2}) should be > low volatility width ({width1})");
+    }
+
+    [Fact]
+    public void BandsSymmetric_AroundMiddle()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 20; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i + Math.Sin(i) * 3));
+        }
+
+        double upperDist = ind.Upper.Value - ind.Last.Value;
+        double lowerDist = ind.Last.Value - ind.Lower.Value;
+
+        Assert.Equal(upperDist, lowerDist, 1e-10);
+    }
+
+    [Fact]
+    public void MultiplierAffectsBandWidth()
+    {
+        var ind1 = new Regchannel(10, 1.0);
+        var ind2 = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 20; i++)
+        {
+            double val = 100 + i + Math.Sin(i) * 3;
+            ind1.Update(new TValue(now.AddMinutes(i), val));
+            ind2.Update(new TValue(now.AddMinutes(i), val));
+        }
+
+        double width1 = ind1.Upper.Value - ind1.Lower.Value;
+        double width2 = ind2.Upper.Value - ind2.Lower.Value;
+
+        Assert.Equal(width2, width1 * 2, 1e-9);
+    }
+
+    [Fact]
+    public void IsNew_False_RollsBackState()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        // Add some initial data
+        for (int i = 0; i < 15; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+        }
+
+        // Add new bar
+        ind.Update(new TValue(now.AddMinutes(15), 200), isNew: true);
+        var lastAfterNew = ind.Last.Value;
+
+        // Update same bar with different value (isNew=false)
+        ind.Update(new TValue(now.AddMinutes(15), 116), isNew: false);
+
+        // Should be different from the 200 update
+        Assert.NotEqual(lastAfterNew, ind.Last.Value);
+    }
+
+    [Fact]
+    public void IsNew_False_IterativeCorrections()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 15; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+        }
+
+        // Multiple corrections to same bar
+        ind.Update(new TValue(now.AddMinutes(15), 150), isNew: true);
+        var first = ind.Last.Value;
+
+        ind.Update(new TValue(now.AddMinutes(15), 160), isNew: false);
+        var second = ind.Last.Value;
+
+        ind.Update(new TValue(now.AddMinutes(15), 155), isNew: false);
+        var third = ind.Last.Value;
+
+        // All should be different (different inputs)
+        Assert.NotEqual(first, second);
+        Assert.NotEqual(second, third);
+        Assert.NotEqual(first, third);
+    }
+
+    [Fact]
+    public void NaN_UsesLastValidValue()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 10; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+        }
+
+        // Update with NaN
+        ind.Update(new TValue(now.AddMinutes(10), double.NaN));
+
+        // Should still produce finite result
+        Assert.True(double.IsFinite(ind.Last.Value));
+        Assert.True(double.IsFinite(ind.Upper.Value));
+        Assert.True(double.IsFinite(ind.Lower.Value));
+    }
+
+    [Fact]
+    public void Infinity_UsesLastValidValue()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 10; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+        }
+
+        ind.Update(new TValue(now.AddMinutes(10), double.PositiveInfinity));
+
+        Assert.True(double.IsFinite(ind.Last.Value));
+        Assert.True(double.IsFinite(ind.Upper.Value));
+        Assert.True(double.IsFinite(ind.Lower.Value));
+    }
+
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 20; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+        }
+
+        Assert.True(ind.IsHot);
+
+        ind.Reset();
+
+        Assert.False(ind.IsHot);
+        Assert.Equal(default, ind.Last);
+        Assert.Equal(default, ind.Upper);
+        Assert.Equal(default, ind.Lower);
+        Assert.Equal(0, ind.Slope);
+        Assert.Equal(0, ind.StdDev);
+    }
+
+    [Fact]
+    public void IsHot_BecomesTrue_AfterWarmup()
+    {
+        var ind = new Regchannel(10, 2.0);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 9; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+            Assert.False(ind.IsHot, $"Should not be hot at bar {i + 1}");
+        }
+
+        ind.Update(new TValue(now.AddMinutes(9), 109));
+        Assert.True(ind.IsHot, "Should be hot after 10 bars");
+    }
+
+    [Fact]
+    public void BatchVsStreaming_Match()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+        var source = new TSeries();
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            source.Add(new TValue(bar.Time, bar.Close));
+        }
+
+        // Streaming
+        var streamMiddle = new List<double>(source.Count);
+        var streamUpper = new List<double>(source.Count);
+        var streamLower = new List<double>(source.Count);
+
+        foreach (var item in source)
+        {
+            ind.Update(item);
+            streamMiddle.Add(ind.Last.Value);
+            streamUpper.Add(ind.Upper.Value);
+            streamLower.Add(ind.Lower.Value);
+        }
+
+        // Batch
+        var (batchMiddle, batchUpper, batchLower) = Regchannel.Batch(source, TestPeriod, TestMultiplier);
+
+        // Compare last 80 values (after warmup)
+        for (int i = 20; i < source.Count; i++)
+        {
+            Assert.Equal(streamMiddle[i], batchMiddle[i].Value, 1e-9);
+            Assert.Equal(streamUpper[i], batchUpper[i].Value, 1e-9);
+            Assert.Equal(streamLower[i], batchLower[i].Value, 1e-9);
+        }
+    }
+
+    [Fact]
+    public void SpanBatch_MatchesStreaming()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+        var source = new TSeries();
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            source.Add(new TValue(bar.Time, bar.Close));
+        }
+
+        // Streaming
+        var streamMiddle = new List<double>(source.Count);
+        var streamUpper = new List<double>(source.Count);
+        var streamLower = new List<double>(source.Count);
+
+        foreach (var item in source)
+        {
+            ind.Update(item);
+            streamMiddle.Add(ind.Last.Value);
+            streamUpper.Add(ind.Upper.Value);
+            streamLower.Add(ind.Lower.Value);
+        }
+
+        // Span batch
+        var middle = new double[source.Count];
+        var upper = new double[source.Count];
+        var lower = new double[source.Count];
+
+        Regchannel.Batch(source.Values, middle, upper, lower, TestPeriod, TestMultiplier);
+
+        // Compare last 80 values
+        for (int i = 20; i < source.Count; i++)
+        {
+            Assert.Equal(streamMiddle[i], middle[i], 1e-9);
+            Assert.Equal(streamUpper[i], upper[i], 1e-9);
+            Assert.Equal(streamLower[i], lower[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void SpanBatch_ValidatesOutputLength()
+    {
+        var source = new double[100];
+        var middle = new double[50]; // Too short
+        var upper = new double[100];
+        var lower = new double[100];
+
+        Assert.Throws<ArgumentException>(() =>
+            Regchannel.Batch(source, middle, upper, lower, 10));
+    }
+
+    [Fact]
+    public void SpanBatch_ValidatesPeriod()
+    {
+        var source = new double[100];
+        var middle = new double[100];
+        var upper = new double[100];
+        var lower = new double[100];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() =>
+            Regchannel.Batch(source, middle, upper, lower, 1));
+    }
+
+    [Fact]
+    public void SpanBatch_ValidatesMultiplier()
+    {
+        var source = new double[100];
+        var middle = new double[100];
+        var upper = new double[100];
+        var lower = new double[100];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() =>
+            Regchannel.Batch(source, middle, upper, lower, 10, 0));
+    }
+
+    [Fact]
+    public void Event_FiresOnUpdate()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+        var now = DateTime.UtcNow;
+        int eventCount = 0;
+
+        ind.Pub += (object? sender, in TValueEventArgs e) => eventCount++;
+
+        for (int i = 0; i < 30; i++)
+        {
+            ind.Update(new TValue(now.AddMinutes(i), 100 + i));
+        }
+
+        Assert.Equal(30, eventCount);
+    }
+
+    [Fact]
+    public void LongSeries_StableResults()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+        var now = DateTime.UtcNow;
+
+        for (int i = 0; i < 10000; i++)
+        {
+            double val = 100 + Math.Sin(i * 0.01) * 10 + i * 0.001;
+            ind.Update(new TValue(now.AddMinutes(i), val));
+        }
+
+        Assert.True(double.IsFinite(ind.Last.Value));
+        Assert.True(double.IsFinite(ind.Upper.Value));
+        Assert.True(double.IsFinite(ind.Lower.Value));
+        Assert.True(double.IsFinite(ind.Slope));
+        Assert.True(double.IsFinite(ind.StdDev));
+        Assert.True(ind.Upper.Value >= ind.Last.Value);
+        Assert.True(ind.Lower.Value <= ind.Last.Value);
+    }
+
+    [Fact]
+    public void Prime_SetsCorrectState()
+    {
+        var ind = new Regchannel(TestPeriod, TestMultiplier);
+        var source = new TSeries();
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            source.Add(new TValue(bar.Time, bar.Close));
+        }
+
+        ind.Prime(source);
+
+        Assert.True(ind.IsHot);
+        Assert.True(double.IsFinite(ind.Last.Value));
+        Assert.True(double.IsFinite(ind.Upper.Value));
+        Assert.True(double.IsFinite(ind.Lower.Value));
+    }
+
+    [Fact]
+    public void Calculate_ReturnsIndicatorAndResults()
+    {
+        var source = new TSeries();
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            source.Add(new TValue(bar.Time, bar.Close));
+        }
+
+        var (results, indicator) = Regchannel.Calculate(source, TestPeriod, TestMultiplier);
+
+        Assert.NotNull(indicator);
+        Assert.True(indicator.IsHot);
+        Assert.Equal(source.Count, results.Middle.Count);
+        Assert.Equal(source.Count, results.Upper.Count);
+        Assert.Equal(source.Count, results.Lower.Count);
+    }
+}
@@ -0,0 +1,536 @@
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public sealed class RegchannelValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public RegchannelValidationTests(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 Regchannel(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
+        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)
+        // slope = 5, intercept = 105, regression at x=2 = 115
+        ind.Update(series[2]);
+        Assert.Equal(115.0, ind.Last.Value, 1e-10);
+        Assert.Equal(5.0, ind.Slope, 1e-10);
+
+        // Residuals: 100-105=-5, 120-110=10, 110-115=-5
+        // StdDev = sqrt((25+100+25)/3) = sqrt(50)
+        double expectedStdDev = Math.Sqrt(50);
+        Assert.Equal(expectedStdDev, ind.StdDev, 1e-10);
+
+        _output.WriteLine("Regchannel 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 Regchannel(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("Regchannel 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 Regchannel(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("Regchannel 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 Regchannel(period, multiplier);
+                var (bMid, bUp, bLo) = inst.Update(_testData.Data);
+
+                // Static batch
+                var (sMid, sUp, sLo) = Regchannel.Batch(_testData.Data, period, multiplier);
+
+                ValidationHelper.VerifySeriesEqual(bMid, sMid);
+                ValidationHelper.VerifySeriesEqual(bUp, sUp);
+                ValidationHelper.VerifySeriesEqual(bLo, sLo);
+
+                // Streaming
+                var streaming = new Regchannel(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];
+                Regchannel.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("Regchannel 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 Regchannel(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) = Regchannel.Batch(_testData.Data, period, multiplier);
+
+        ValidationHelper.VerifySeriesEqual(bMid, evtMid);
+        ValidationHelper.VerifySeriesEqual(bUp, evtUp);
+        ValidationHelper.VerifySeriesEqual(bLo, evtLo);
+
+        _output.WriteLine("Regchannel eventing mode validated");
+    }
+
+    [Fact]
+    public void Validate_Calculate_ReturnsHotIndicator()
+    {
+        const int period = 15;
+        const double multiplier = 2.5;
+
+        var ((mid, up, lo), ind) = Regchannel.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("Regchannel Calculate validated");
+    }
+
+    [Fact]
+    public void Validate_Prime_MatchesBatch()
+    {
+        const int period = 25;
+        const double multiplier = 1.5;
+
+        var (bMid, bUp, bLo) = Regchannel.Batch(_testData.Data, period, multiplier);
+
+        var primed = new Regchannel(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("Regchannel Prime validated against batch");
+    }
+
+    [Fact]
+    public void Validate_LargeDataset_FiniteOutputs()
+    {
+        var (mid, up, lo) = Regchannel.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("Regchannel large dataset validated");
+    }
+
+    [Fact]
+    public void Validate_BandSymmetry_AllBars()
+    {
+        var ind = new Regchannel(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("Regchannel 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 Regchannel(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("Regchannel 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 Regchannel(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("Regchannel period effect validated");
+    }
+
+    [Fact]
+    public void Validate_StateRestoration_Iterative()
+    {
+        var ind = new Regchannel(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("Regchannel state restoration validated");
+    }
+
+    [Fact]
+    public void Validate_BandWidthFormula()
+    {
+        // Band width = 2 * multiplier * stdDev
+        var ind = new Regchannel(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("Regchannel 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 Regchannel(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 Regchannel(10, 2.0);
+        foreach (var tv in downtrend)
+        {
+            indDown.Update(tv);
+        }
+        Assert.True(indDown.Slope < 0, "Downtrend should have negative slope");
+
+        _output.WriteLine("Regchannel slope direction validated");
+    }
+
+    [Fact]
+    public void Validate_SlidingWindow_Correctness()
+    {
+        const int period = 5;
+        var ind = new Regchannel(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 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("Regchannel sliding window validated");
+    }
+
+    [Fact]
+    public void Validate_Residuals_NonLinearData()
+    {
+        // Test with data that doesn't fit a perfect line
+        var ind = new Regchannel(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("Regchannel residuals for non-linear data validated");
+    }
+
+    [Fact]
+    public void Validate_StdDev_Formula()
+    {
+        // Verify stdDev calculation: sqrt(sum(residual^2)/n)
+        var ind = new Regchannel(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("Regchannel stdDev formula validated");
+    }
+}
@@ -0,0 +1,445 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// REGCHANNEL: Regression Channel
+/// Linear regression centerline with bands at ±multiplier × standard deviation of residuals.
+/// </summary>
+/// <remarks>
+/// The Regression 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:raff_regression_channel
+/// </remarks>
+[SkipLocalsInit]
+public sealed class Regchannel : 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;
+
+    /// <summary>
+    /// Initializes a new instance of the Regchannel indicator.
+    /// </summary>
+    /// <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 Regchannel(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 = $"Regchannel({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 Regchannel(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, Regchannel Indicator) Calculate(TSeries source, int period = 20, double multiplier = 2.0)
+    {
+        var indicator = new Regchannel(source, period, multiplier);
+        var results = indicator.Update(source);
+        return (results, indicator);
+    }
+}
@@ -1,138 +1,163 @@
-# REGCHANNEL: Regression Channels
+# REGCHANNEL: Linear Regression Channel

-## Overview and Purpose
+> "Linear regression isn't about predicting the future—it's about understanding where price *should* be given recent history, and measuring how far it's strayed."

-Regression Channels are a technical analysis tool that creates a channel formed by parallel lines equidistant from a central linear regression line. Unlike fixed channels based on price extremes, regression channels use statistical analysis to identify the underlying trend direction and create bands that reflect the normal deviation of prices from this trend. The central regression line represents the best-fit line through recent price data, while the upper and lower bands are positioned at a specified number of standard deviations away from this trend line.
+The Linear Regression Channel (REGCHANNEL) plots a best-fit line through price data over a specified period, with parallel bands at a configurable standard deviation distance. This implementation uses ordinary least squares (OLS) regression with population standard deviation of residuals, providing a statistically grounded view of trend direction and price deviation.

-This approach provides traders with a statistically-based framework for identifying overbought and oversold conditions relative to the prevailing trend, making it particularly useful for trend-following strategies and mean reversion trading around the regression line. The implementation uses efficient least-squares calculation methods to ensure optimal performance while providing mathematically accurate trend analysis.
+## Historical Context

-## Core Concepts
+Linear regression channels emerged from basic statistical analysis applied to financial markets. The concept combines two fundamental statistical tools: linear regression (fitting a line to minimize squared errors) and standard deviation (measuring dispersion around that line).

-* **Statistical trend identification:** Uses linear regression to determine the most probable price direction based on historical data
-* **Standard deviation bands:** Creates upper and lower boundaries based on the standard deviation of price residuals from the regression line
-* **Trend-relative analysis:** Provides overbought/oversold signals relative to the statistical trend rather than absolute price levels
-* **Adaptive channel width:** Channel bands automatically adjust to market volatility through standard deviation calculations
-* **Mathematical precision:** Based on rigorous statistical methods rather than subjective trend line drawing
+Unlike moving average envelopes that simply offset from a smoothed price, regression channels adapt their slope to the underlying trend and their width to actual price volatility around that trend. This makes them particularly useful for identifying when prices have deviated significantly from their recent trajectory.

-Regression Channels differ from other channel indicators by using mathematical optimization to determine the central trend line, rather than connecting price extremes or using moving averages. This approach provides a more objective view of trend direction and creates channels that better reflect the statistical nature of price movements around the underlying trend.
+The indicator is functionally identical to SDCHANNEL but uses "Regchannel" naming convention, which may be preferred in some trading platforms and literature.

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

-| Parameter | Default | Function | When to Adjust |
-| ------ | ------ | ------ | ------ |
-| Period | 20 | Lookback window for regression calculation | Shorter (10-15) for more responsive trend identification; longer (30-50) for smoother, more stable trends |
-| Source | Close | Price data used for regression analysis | Rarely changed; could use HLC3 for more balanced analysis |
-| Multiplier | 3.0 | Standard deviation multiplier for band distance | Higher values (2.5-3.0) for wider bands with fewer signals; lower values (1.5-1.8) for tighter bands with more frequent signals |
+### 1. Sliding Window Buffer

-**Pro Tip:** For swing trading, consider using period = 25 with multiplier = 2.5 to capture intermediate-term trends while filtering minor fluctuations. For day trading, period = 14 with multiplier = 2.0 provides more responsive signals while maintaining statistical validity. The regression line often acts as dynamic support/resistance during trending markets.
+The indicator maintains a rolling window of the most recent `period` price values:

-## Calculation and Mathematical Foundation
+$$
+W_t = \{P_{t-n+1}, P_{t-n+2}, \ldots, P_t\}
+$$

-**Simplified explanation:**
-Regression Channels calculate a linear regression line through recent price data to identify the underlying trend, then create parallel bands above and below this line based on the standard deviation of how much prices typically deviate from the trend.
+where $n = \min(t+1, \text{period})$. During warmup ($t < \text{period}$), all available values are used.

-**Technical formula:**
+### 2. Linear Regression via Least Squares

-```
-Linear Regression:
-slope = (n × Σ(xy) - Σ(x) × Σ(y)) / (n × Σ(x²) - (Σ(x))²)
-intercept = (Σ(y) - slope × Σ(x)) / n
-regression_line = slope × x + intercept
+For each update, the indicator computes the best-fit line $y = mx + b$ using the normal equations:

-Standard Deviation of Residuals:
-residual[i] = actual_price[i] - predicted_price[i]
-std_dev = √(Σ(residual²) / n)
+$$
+m = \frac{n \sum_{i=0}^{n-1} x_i y_i - \sum_{i=0}^{n-1} x_i \sum_{i=0}^{n-1} y_i}{n \sum_{i=0}^{n-1} x_i^2 - \left(\sum_{i=0}^{n-1} x_i\right)^2}
+$$

-Channel Bands:
-upper_band = regression_line + (multiplier × std_dev)
-lower_band = regression_line - (multiplier × std_dev)
-```
+$$
+b = \frac{\sum_{i=0}^{n-1} y_i - m \sum_{i=0}^{n-1} x_i}{n}
+$$

-Where:
-* n = period length
-* x = time index (0, 1, 2, ..., n-1)
-* y = price values over the period
-* multiplier = standard deviation multiplier (typically 2.0)
+where $x_i = i$ (time index) and $y_i = P_i$ (price at that index).

-> 🔍 **Technical Note:** The implementation uses the least-squares method to calculate the optimal linear regression line that minimizes the sum of squared residuals. The standard deviation calculation uses the population formula (dividing by n) rather than the sample formula (n-1) to maintain consistency with the regression period and provide appropriate channel width scaling.
+### 3. Regression Value Calculation

-## Interpretation Details
+The middle line value at the current bar (rightmost point of the regression line):

-Regression Channels provide sophisticated trend and mean reversion analysis:
+$$
+\text{Middle}_t = m \cdot (n-1) + b
+$$

-* **Trend identification:** The slope of the regression line indicates trend direction and strength - steeper slopes suggest stronger trends
-* **Channel breakouts:** Price breaking above the upper band suggests potential bullish momentum; breaking below the lower band indicates bearish pressure
-* **Mean reversion opportunities:** Price touching either band often presents opportunities for trades back toward the regression line
-* **Support/resistance levels:** The regression line frequently acts as dynamic support in uptrends and resistance in downtrends
-* **Trend strength assessment:** Narrower channels indicate consistent trends; wider channels suggest more volatile or sideways markets
-* **Entry timing:** Price near the lower band in uptrends or upper band in downtrends can provide favorable entry points
-* **Exit signals:** Channel breaks in the opposite direction of the main trend may signal trend exhaustion
-* **Volatility measurement:** Channel width provides insight into current market volatility relative to the trend
+This represents the expected price based on the linear trend through the window.
+
+### 4. Standard Deviation of Residuals
+
+The indicator computes population standard deviation of the residuals (differences between actual and predicted values):
+
+$$
+\sigma_t = \sqrt{\frac{\sum_{i=0}^{n-1} (y_i - \hat{y}_i)^2}{n}}
+$$
+
+where $\hat{y}_i = m \cdot i + b$ is the predicted value at position $i$.
+
+### 5. Channel Bands
+
+Upper and lower bands are placed at a configurable multiple of the standard deviation:
+
+$$
+\text{Upper}_t = \text{Middle}_t + k \cdot \sigma_t
+$$
+
+$$
+\text{Lower}_t = \text{Middle}_t - k \cdot \sigma_t
+$$
+
+where $k$ is the multiplier parameter (default 2.0).
+
+## Mathematical Foundation
+
+### Efficient Computation Using Running Sums
+
+Rather than recalculating sums from scratch each bar, the implementation maintains running sums and adjusts them incrementally. For a sliding window of size $n$:
+
+- $\sum x = 0 + 1 + \ldots + (n-1) = \frac{n(n-1)}{2}$
+- $\sum x^2 = 0^2 + 1^2 + \ldots + (n-1)^2 = \frac{n(n-1)(2n-1)}{6}$
+
+These are constants for a fixed period, computed once at construction.
+
+### Denominator and Numerical Stability
+
+The denominator in the slope calculation:
+
+$$
+D = n \sum x^2 - \left(\sum x\right)^2
+$$
+
+For $n \geq 2$, this is always positive, ensuring numerical stability. The implementation guards against $D = 0$ (which can only occur for $n = 1$).
+
+### Residual Calculation
+
+For each point in the window:
+
+$$
+r_i = y_i - (m \cdot i + b)
+$$
+
+The sum of squared residuals:
+
+$$
+\text{SSR} = \sum_{i=0}^{n-1} r_i^2
+$$

 ## Performance Profile

-### Operation Count (Streaming Mode, per Bar)
-
-Linear regression with standard deviation bands requires maintaining running sums for least-squares calculation:
+### Operation Count (Streaming Mode, Scalar)

 | Operation | Count | Cost (cycles) | Subtotal |
 | :--- | :---: | :---: | :---: |
-| ADD/SUB | 8 | 1 | 8 |
-| MUL | 6 | 3 | 18 |
+| ADD/SUB | ~3n+15 | 1 | ~3n+15 |
+| MUL | ~2n+10 | 3 | ~6n+30 |
 | DIV | 4 | 15 | 60 |
 | SQRT | 1 | 15 | 15 |
-| **Total** | **19** | — | **~101 cycles** |
+| Ring buffer ops | 2 | 5 | 10 |
+| **Total** | — | — | **~9n+130** |

-**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 and variance: 1 SUB + 1 MUL + 1 DIV = 19 cycles
- Std dev + bands: 1 SQRT + 1 MUL + 2 ADD = 21 cycles
-
-### Complexity Analysis
-
-| Mode | Complexity | Notes |
-| :--- | :---: | :--- |
-| Streaming | O(1) | Running sums with sliding window updates |
-| Batch | O(n) | Linear scan, optimized with running sums |
-
-**Memory**: ~80 bytes (running sums for x, y, xy, x², residual sum)
-
-### SIMD Analysis
-
-| Optimization | Applicable | Notes |
-| :--- | :---: | :--- |
-| AVX2 vectorization | Partial | Batch residual calculation vectorizable |
-| FMA | ✅ | `slope * x + intercept` pattern |
-| Batch parallelism | Partial | Running sums limit parallelization |
-
-**Note:** Linear regression is inherently sequential due to running sum dependencies, but residual calculations and band plotting can leverage SIMD in batch mode.
+For period=20: approximately 310 cycles per bar.

 ### Quality Metrics

 | Metric | Score | Notes |
 | :--- | :---: | :--- |
-| **Accuracy** | 9/10 | Statistically optimal least-squares fit |
-| **Timeliness** | 6/10 | Lag proportional to period length |
-| **Overshoot** | 8/10 | Linear assumption limits overshoot |
-| **Smoothness** | 8/10 | Regression line inherently smooth |
+| **Accuracy** | 9/10 | Exact OLS regression; population σ |
+| **Timeliness** | 7/10 | Inherent lag from lookback window |
+| **Smoothness** | 8/10 | Regression naturally smooths |
+| **Responsiveness** | 6/10 | Slower to react than EMA-based channels |

-## Limitations and Considerations
+## Validation

-* **Lagging indicator:** Based on historical data, the regression line and bands will lag significant trend changes
-* **Period sensitivity:** Different period lengths can produce significantly different channel orientations and widths
-* **Linear assumption:** Assumes price relationships are linear, which may not hold during complex market movements
-* **Breakout confirmation:** Not all band breaks result in significant price movements; requires additional confirmation
-* **Sideways markets:** Less effective during ranging or choppy market conditions where no clear trend exists
-* **Parameter optimization:** Multiplier and period settings may require adjustment for different market conditions and timeframes
-* **Statistical basis:** Assumes price deviations follow normal distribution patterns around the trend line
-* **Trend transition periods:** May provide conflicting signals during major trend reversals or consolidation phases
+| Library | Status | Notes |
+| :--- | :---: | :--- |
+| **TA-Lib** | N/A | No direct equivalent |
+| **Skender** | N/A | No direct equivalent |
+| **Tulip** | N/A | No direct equivalent |
+| **Manual** | ✅ | Verified against hand calculations |
+
+Linear regression channels are not commonly found in standard TA libraries with this exact specification. Validation relies on mathematical verification against known formulas.
+
+## Common Pitfalls
+
+1. **Warmup Period**: The indicator requires `period` bars to reach full accuracy. During warmup, it uses all available data but may produce different results than post-warmup.
+
+2. **Slope Interpretation**: A positive slope indicates uptrend within the window; negative indicates downtrend. The magnitude indicates trend strength.
+
+3. **Band Width = 0**: When prices fall perfectly on a line (zero residuals), bands collapse to the middle line. This is mathematically correct but visually unexpected.
+
+4. **Standard Deviation Choice**: This implementation uses population σ (dividing by n), not sample σ (dividing by n-1). Some implementations differ.
+
+5. **Memory Footprint**: Each instance requires a RingBuffer of `period` doubles (~8 bytes each) plus state structs (~80 bytes). For period=20: ~240 bytes per instance.
+
+6. **isNew Parameter**: When `isNew=false`, the indicator rolls back to the previous state before incorporating the update. This enables bar correction without state accumulation errors.

 ## 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.
-* Pardo, R. (2008). The Evaluation and Optimization of Trading Strategies. John Wiley & Sons.
+- Draper, N.R. & Smith, H. (1998). "Applied Regression Analysis." Wiley.
+- Murphy, J.J. (1999). "Technical Analysis of the Financial Markets." New York Institute of Finance.
+- PineScript Reference: Linear Regression implementation patterns.