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-19 11:08:05 +00:00 · 2026-01-21 14:41:31 -05:00
parent b2c1787782
commit 3eae9a76fe
71 changed files with 15716 additions and 772 deletions
@@ -0,0 +1,166 @@
+using TradingPlatform.BusinessLayer;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class FcbIndicatorTests
+{
+    [Fact]
+    public void Constructor_SetsDefaults()
+    {
+        var ind = new FcbIndicator();
+
+        Assert.Equal(20, ind.Period);
+        Assert.True(ind.ShowColdValues);
+        Assert.Equal("Fcb - Fractal Chaos Bands", ind.Name);
+        Assert.False(ind.SeparateWindow);
+        Assert.True(ind.OnBackGround);
+    }
+
+    [Fact]
+    public void MinHistoryDepths_EqualsPeriodPlusTwo()
+    {
+        var ind = new FcbIndicator { Period = 15 };
+        Assert.Equal(17, ind.MinHistoryDepths); // Period + 2 for fractal detection
+    }
+
+    [Fact]
+    public void ShortName_ReflectsParameters()
+    {
+        var ind = new FcbIndicator { Period = 12 };
+        Assert.Contains("12", ind.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Initialize_AddsThreeLineSeries()
+    {
+        var ind = new FcbIndicator { Period = 14 };
+        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 FcbIndicator { Period = 3 };
+        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 FcbIndicator { Period = 3 };
+        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 FcbIndicator { Period = 5 };
+        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 FcbIndicator { Period = 5 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; 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(10, ind.LinesSeries[0].Count);
+        Assert.Equal(10, ind.LinesSeries[1].Count);
+        Assert.Equal(10, ind.LinesSeries[2].Count);
+
+        for (int i = 0; i < 10; 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 FcbIndicator { Period = 3 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        // Create fractal patterns
+        for (int i = 0; i < 10; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100, 110 + i, 90 - i, 100, 1000);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        Assert.True(upper >= middle, $"Upper ({upper}) should be >= Middle ({middle})");
+        Assert.True(lower <= middle, $"Lower ({lower}) should be <= Middle ({middle})");
+    }
+
+    [Fact]
+    public void FractalDetection_WorksCorrectly()
+    {
+        var ind = new FcbIndicator { Period = 5 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Create clear fractal high pattern: 100, 120, 110 (index 1 is fractal high)
+        // Create clear fractal low pattern: 90, 70, 80 (index 1 is fractal low)
+        ind.HistoricalData.AddBar(now.AddMinutes(0), 95, 100, 90, 95);
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        ind.HistoricalData.AddBar(now.AddMinutes(1), 95, 120, 70, 95); // Potential fractal
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        ind.HistoricalData.AddBar(now.AddMinutes(2), 95, 110, 80, 95); // Confirms fractals
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        // After 3 bars, we should have detected fractals
+        Assert.Equal(3, 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)));
+    }
+}
@@ -0,0 +1,69 @@
+using System.Drawing;
+using TradingPlatform.BusinessLayer;
+using static QuanTAlib.IndicatorExtensions;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// Fcb: Fractal Chaos Bands - Quantower Indicator Adapter
+/// Tracks the highest fractal high and lowest fractal low over a lookback period.
+/// A fractal high occurs when high[1] > high[0] and high[1] > high[2] (3-bar pattern).
+/// A fractal low occurs when low[1] < low[0] and low[1] < low[2] (3-bar pattern).
+/// Uses monotonic deques for O(1) amortized complexity.
+/// </summary>
+public sealed class FcbIndicator : Indicator, IWatchlistIndicator
+{
+    [InputParameter("Period", sortIndex: 10, minimum: 1, maximum: 500, increment: 1, decimalPlaces: 0)]
+    public int Period { get; set; } = 20;
+
+    [InputParameter("Show Cold Values", sortIndex: 100)]
+    public bool ShowColdValues { get; set; } = true;
+
+    private Fcb? _indicator;
+
+    public int MinHistoryDepths => Period + 2; // Period + 2 for fractal detection
+    public override string ShortName => $"Fcb({Period})";
+
+    public FcbIndicator()
+    {
+        Name = "Fcb - Fractal Chaos Bands";
+        Description = "Price channel using fractal highs and lows with midpoint average";
+        SeparateWindow = false;
+        OnBackGround = true;
+    }
+
+    protected override void OnInit()
+    {
+        _indicator = new Fcb(Period);
+
+        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();
+
+        TBar input = new(
+            time: item.TimeLeft,
+            open: item[PriceType.Open],
+            high: item[PriceType.High],
+            low: item[PriceType.Low],
+            close: item[PriceType.Close],
+            volume: item[PriceType.Volume]
+        );
+
+        _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,322 @@
+using System;
+using QuanTAlib;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class FcbTests
+{
+    [Fact]
+    public void Fcb_Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Fcb(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Fcb(-5));
+
+        var f = new Fcb(10);
+        Assert.Equal(12, f.WarmupPeriod); // period + 2 for fractal detection
+        Assert.Contains("Fcb", f.Name, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Fcb_InitialState_Defaults()
+    {
+        var f = new Fcb(5);
+
+        Assert.Equal(0, f.Last.Value);
+        Assert.Equal(0, f.Upper.Value);
+        Assert.Equal(0, f.Lower.Value);
+        Assert.False(f.IsHot);
+    }
+
+    [Fact]
+    public void Fcb_DetectsFractalHigh()
+    {
+        // Fractal high: high[1] > high[2] AND high[1] > high[0]
+        // Create pattern: 100, 120, 110 (index 1 is fractal high = 120)
+        var f = new Fcb(5);
+
+        f.Update(new TBar(DateTime.UtcNow, 95, 100, 90, 95, 1000));   // High = 100
+        f.Update(new TBar(DateTime.UtcNow, 115, 120, 110, 115, 1000)); // High = 120 (will be fractal)
+        f.Update(new TBar(DateTime.UtcNow, 105, 110, 100, 105, 1000)); // High = 110 < 120
+
+        // After 3 bars, fractal high at index 1 detected when we get index 2
+        // Upper should track the highest fractal high = 120
+        Assert.Equal(120.0, f.Upper.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Fcb_DetectsFractalLow()
+    {
+        // Fractal low: low[1] < low[2] AND low[1] < low[0]
+        // Create pattern: 100, 80, 90 (index 1 is fractal low = 80)
+        var f = new Fcb(5);
+
+        f.Update(new TBar(DateTime.UtcNow, 105, 110, 100, 105, 1000)); // Low = 100
+        f.Update(new TBar(DateTime.UtcNow, 85, 90, 80, 85, 1000));    // Low = 80 (will be fractal)
+        f.Update(new TBar(DateTime.UtcNow, 95, 100, 90, 95, 1000));   // Low = 90 > 80
+
+        // After 3 bars, fractal low at index 1 detected when we get index 2
+        // Lower should track the lowest fractal low = 80
+        Assert.Equal(80.0, f.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Fcb_NoFractalUsesPreviousValue()
+    {
+        // If no fractal is detected, bands should use previous fractal values
+        var f = new Fcb(5);
+
+        // Create fractal high then no new fractals
+        f.Update(new TBar(DateTime.UtcNow, 100, 105, 95, 100, 1000));
+        f.Update(new TBar(DateTime.UtcNow, 110, 115, 105, 110, 1000)); // Will be fractal high
+        f.Update(new TBar(DateTime.UtcNow, 105, 110, 100, 105, 1000)); // Confirms fractal at 115
+
+        _ = f.Upper.Value; // Store for comparison
+
+        // Add more bars that don't create new fractals (monotonic up)
+        f.Update(new TBar(DateTime.UtcNow, 112, 117, 107, 112, 1000));
+        f.Update(new TBar(DateTime.UtcNow, 120, 125, 115, 120, 1000));
+
+        // Upper should still be finite as previous fractal value is tracked via deque
+        Assert.True(double.IsFinite(f.Upper.Value));
+    }
+
+    [Fact]
+    public void Fcb_SlidingWindow_Updates()
+    {
+        var f = new Fcb(3);
+
+        // Create initial fractals
+        f.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 100, 1000));
+        f.Update(new TBar(DateTime.UtcNow, 110, 120, 100, 110, 1000)); // Fractal high at 120
+        f.Update(new TBar(DateTime.UtcNow, 105, 115, 95, 105, 1000));
+
+        // Add more bars - window should slide
+        for (int i = 0; i < 5; i++)
+        {
+            f.Update(new TBar(DateTime.UtcNow, 90 - i, 95 - i, 85 - i, 90 - i, 1000));
+        }
+
+        // Upper may have changed as old fractals slide out
+        Assert.NotEqual(0, f.Upper.Value);
+        Assert.NotEqual(0, f.Lower.Value);
+    }
+
+    [Fact]
+    public void Fcb_IsHot_TurnsTrueAfterWarmup()
+    {
+        var f = new Fcb(4);
+        // WarmupPeriod = 4 + 2 = 6
+
+        for (int i = 0; i < 5; i++)
+        {
+            f.Update(new TBar(DateTime.UtcNow, 100 + i, 101 + i, 99 + i, 100 + i, 1000));
+            Assert.False(f.IsHot);
+        }
+
+        f.Update(new TBar(DateTime.UtcNow, 200, 201, 199, 200, 1000));
+        Assert.True(f.IsHot);
+    }
+
+    [Fact]
+    public void Fcb_IsNewFalse_RebuildsState()
+    {
+        var f = new Fcb(3);
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 7);
+
+        TBar remembered = default;
+        for (int i = 0; i < 10; i++)
+        {
+            remembered = gbm.Next(isNew: true);
+            f.Update(remembered, isNew: true);
+        }
+
+        double mid = f.Last.Value;
+        double up = f.Upper.Value;
+        double lo = f.Lower.Value;
+
+        // Apply corrections
+        for (int i = 0; i < 3; i++)
+        {
+            var corrected = gbm.Next(isNew: false);
+            f.Update(corrected, isNew: false);
+        }
+
+        // Restore with remembered bar
+        f.Update(remembered, isNew: false);
+
+        Assert.Equal(mid, f.Last.Value, 1e-10);
+        Assert.Equal(up, f.Upper.Value, 1e-10);
+        Assert.Equal(lo, f.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Fcb_NaN_UsesLastValid()
+    {
+        var f = new Fcb(3);
+
+        f.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000));
+        f.Update(new TBar(DateTime.UtcNow, 101, 111, 91, 106, 1000));
+
+        var result = f.Update(new TBar(DateTime.UtcNow, 102, double.NaN, 92, 107, 1000));
+        Assert.True(double.IsFinite(result.Value));
+        Assert.True(double.IsFinite(f.Upper.Value));
+        Assert.True(double.IsFinite(f.Lower.Value));
+
+        var result2 = f.Update(new TBar(DateTime.UtcNow, 103, 113, double.PositiveInfinity, 108, 1000));
+        Assert.True(double.IsFinite(result2.Value));
+    }
+
+    [Fact]
+    public void Fcb_Reset_Clears()
+    {
+        var f = new Fcb(3);
+        f.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 100, 1000));
+        f.Update(new TBar(DateTime.UtcNow, 101, 111, 91, 101, 1000));
+        f.Update(new TBar(DateTime.UtcNow, 102, 112, 92, 102, 1000));
+
+        f.Reset();
+
+        Assert.Equal(0, f.Last.Value);
+        Assert.Equal(0, f.Upper.Value);
+        Assert.Equal(0, f.Lower.Value);
+        Assert.False(f.IsHot);
+
+        f.Update(new TBar(DateTime.UtcNow, 50, 60, 40, 55, 1000));
+        Assert.NotEqual(0, f.Last.Value);
+    }
+
+    [Fact]
+    public void Fcb_BatchVsStreaming_Match()
+    {
+        var fStream = new Fcb(10);
+        var gbm = new GBM(startPrice: 100, mu: 0.02, sigma: 0.15, seed: 42);
+        var series = new TBarSeries();
+
+        for (int i = 0; i < 200; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            series.Add(bar);
+            fStream.Update(bar, isNew: true);
+        }
+
+        double expectedMid = fStream.Last.Value;
+        double expectedUp = fStream.Upper.Value;
+        double expectedLo = fStream.Lower.Value;
+
+        var (midBatch, upBatch, loBatch) = Fcb.Batch(series, 10);
+
+        Assert.Equal(expectedMid, midBatch.Last.Value, 1e-10);
+        Assert.Equal(expectedUp, upBatch.Last.Value, 1e-10);
+        Assert.Equal(expectedLo, loBatch.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Fcb_SpanBatch_Validates()
+    {
+        double[] high = [110, 115, 120];
+        double[] low = [90, 95, 100];
+        double[] middle = new double[3];
+        double[] upper = new double[3];
+        double[] lower = new double[3];
+
+        double[] highShort = [110, 115];
+        double[] smallOut = new double[1];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Fcb.Batch(high.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Fcb.Batch(high.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), -1));
+        Assert.Throws<ArgumentException>(() => Fcb.Batch(highShort.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 2));
+        Assert.Throws<ArgumentException>(() => Fcb.Batch(high.AsSpan(), low.AsSpan(), smallOut.AsSpan(), upper.AsSpan(), lower.AsSpan(), 2));
+    }
+
+    [Fact]
+    public void Fcb_SpanBatch_ComputesCorrectly()
+    {
+        // Create data with clear fractal patterns
+        // Fractal high at index 1: 100, 120, 110
+        // Fractal low at index 1: 90, 70, 80
+        double[] high = [100, 120, 110, 115, 105];
+        double[] low = [90, 70, 80, 75, 85];
+        double[] middle = new double[5];
+        double[] upper = new double[5];
+        double[] lower = new double[5];
+
+        Fcb.Batch(high.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 3);
+
+        // At index 2, we detect fractal high=120, fractal low=70
+        // Upper=120, Lower=70, Middle=95
+        Assert.Equal(120.0, upper[2], 1e-10);
+        Assert.Equal(70.0, lower[2], 1e-10);
+        Assert.Equal(95.0, middle[2], 1e-10);
+    }
+
+    [Fact]
+    public void Fcb_Calculate_ReturnsIndicatorAndResults()
+    {
+        var series = new TBarSeries();
+        series.Add(DateTime.UtcNow, 100, 110, 90, 100, 1000);
+        series.Add(DateTime.UtcNow, 105, 120, 80, 105, 1000); // Potential fractal high at 120, low at 80
+        series.Add(DateTime.UtcNow, 102, 115, 85, 102, 1000); // Confirms fractals
+
+        var ((mid, up, lo), ind) = Fcb.Calculate(series, 2);
+
+        // After 3 bars: fractal high = 120, fractal low = 80
+        Assert.Equal(120.0, up.Last.Value, 1e-10);
+        Assert.Equal(80.0, lo.Last.Value, 1e-10);
+        Assert.Equal(100.0, mid.Last.Value, 1e-10);
+
+        // Continue streaming
+        ind.Update(new TBar(DateTime.UtcNow, 108, 130, 75, 108, 1000)); // Potential new fractals
+        ind.Update(new TBar(DateTime.UtcNow, 106, 125, 78, 106, 1000)); // Confirms fractal high=130, low=75
+
+        Assert.Equal(130.0, ind.Upper.Value, 1e-10);
+        Assert.Equal(75.0, ind.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Fcb_Event_Publishes()
+    {
+        var src = new TBarSeries();
+        var f = new Fcb(src, 2);
+        bool fired = false;
+        f.Pub += (object? sender, in TValueEventArgs args) => fired = true;
+
+        src.Add(new TBar(DateTime.UtcNow, 100, 110, 90, 100, 1000));
+        Assert.True(fired);
+    }
+
+    [Fact]
+    public void Fcb_MiddleValue_IsAverage()
+    {
+        var f = new Fcb(3);
+
+        // Create clear fractals
+        f.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 100, 1000));
+        f.Update(new TBar(DateTime.UtcNow, 110, 130, 70, 110, 1000)); // Fractal high=130, low=70
+        f.Update(new TBar(DateTime.UtcNow, 105, 120, 80, 105, 1000)); // Confirms fractals
+
+        double expectedMiddle = (f.Upper.Value + f.Lower.Value) * 0.5;
+        Assert.Equal(expectedMiddle, f.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Fcb_MultipleFractals_TracksHighestLowest()
+    {
+        var f = new Fcb(10);
+
+        // Create multiple fractals over time
+        double[] highs = [100, 120, 110, 115, 140, 130, 125, 150, 145, 142, 148, 155, 150];
+        double[] lows = [90, 70, 80, 75, 60, 65, 68, 50, 55, 58, 52, 45, 48];
+
+        for (int i = 0; i < highs.Length; i++)
+        {
+            f.Update(new TBar(DateTime.UtcNow, (highs[i] + lows[i]) / 2, highs[i], lows[i], (highs[i] + lows[i]) / 2, 1000));
+        }
+
+        // Upper should be highest fractal high in window
+        // Lower should be lowest fractal low in window
+        Assert.True(f.Upper.Value > 0);
+        Assert.True(f.Lower.Value > 0);
+        Assert.True(f.Upper.Value > f.Lower.Value);
+    }
+}
@@ -0,0 +1,284 @@
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public sealed class FcbValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public FcbValidationTests(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_FractalDetection()
+    {
+        var series = new TBarSeries();
+        var t0 = DateTime.UtcNow;
+
+        // Create clear fractal patterns:
+        // Fractal high at bar 1: highs = 100, 120, 110
+        // Fractal low at bar 1: lows = 90, 70, 80
+        series.Add(new TBar(t0, 0, 100, 90, 95, 100));
+        series.Add(new TBar(t0.AddMinutes(1), 0, 120, 70, 95, 100)); // Fractal high=120, low=70
+        series.Add(new TBar(t0.AddMinutes(2), 0, 110, 80, 95, 100)); // Confirms fractals
+
+        var ind = new Fcb(3);
+        var (mid, up, lo) = ind.Update(series);
+
+        // Upper should be highest fractal high = 120
+        // Lower should be lowest fractal low = 70
+        // Middle = (120 + 70) / 2 = 95
+        Assert.Equal(120.0, up.Last.Value, 1e-10);
+        Assert.Equal(70.0, lo.Last.Value, 1e-10);
+        Assert.Equal(95.0, mid.Last.Value, 1e-10);
+
+        _output.WriteLine("FCB manual fractal detection validated");
+    }
+
+    [Fact]
+    public void Validate_AllModes_Consistency()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+
+        foreach (int period in periods)
+        {
+            // Batch (instance)
+            var inst = new Fcb(period);
+            var (bMid, bUp, bLo) = inst.Update(_testData.Bars);
+
+            // Static batch
+            var (sMid, sUp, sLo) = Fcb.Batch(_testData.Bars, period);
+
+            ValidationHelper.VerifySeriesEqual(bMid, sMid);
+            ValidationHelper.VerifySeriesEqual(bUp, sUp);
+            ValidationHelper.VerifySeriesEqual(bLo, sLo);
+
+            // Streaming
+            var streaming = new Fcb(period);
+            var sMidStream = new TSeries();
+            var sUpStream = new TSeries();
+            var sLoStream = new TSeries();
+            foreach (var bar in _testData.Bars)
+            {
+                streaming.Update(bar);
+                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[] high = _testData.HighPrices.ToArray();
+            double[] low = _testData.LowPrices.ToArray();
+            double[] spanMid = new double[high.Length];
+            double[] spanUp = new double[high.Length];
+            double[] spanLo = new double[high.Length];
+            Fcb.Batch(high.AsSpan(), low.AsSpan(),
+                spanMid.AsSpan(), spanUp.AsSpan(), spanLo.AsSpan(), period);
+
+            for (int i = 0; i < high.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("FCB mode consistency validated (batch/stream/span)");
+    }
+
+    [Fact]
+    public void Validate_EventingMode_MatchesBatch()
+    {
+        const int period = 20;
+        var pub = new TBarSeries();
+        var evtInd = new Fcb(pub, period);
+        var evtMid = new TSeries();
+        var evtUp = new TSeries();
+        var evtLo = new TSeries();
+
+        foreach (var bar in _testData.Bars)
+        {
+            pub.Add(bar);
+            evtMid.Add(evtInd.Last);
+            evtUp.Add(evtInd.Upper);
+            evtLo.Add(evtInd.Lower);
+        }
+
+        var (bMid, bUp, bLo) = Fcb.Batch(_testData.Bars, period);
+
+        ValidationHelper.VerifySeriesEqual(bMid, evtMid);
+        ValidationHelper.VerifySeriesEqual(bUp, evtUp);
+        ValidationHelper.VerifySeriesEqual(bLo, evtLo);
+
+        _output.WriteLine("FCB eventing mode validated");
+    }
+
+    [Fact]
+    public void Validate_Calculate_ReturnsHotIndicator()
+    {
+        const int period = 15;
+        var ((mid, up, lo), ind) = Fcb.Calculate(_testData.Bars, period);
+
+        Assert.True(ind.IsHot);
+        Assert.Equal(period + 2, ind.WarmupPeriod); // period + 2 for fractal detection
+        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 TBar(DateTime.UtcNow, 0, 150, 50, 100, 1000);
+        ind.Update(next);
+        Assert.True(ind.IsHot);
+
+        _output.WriteLine("FCB Calculate validated");
+    }
+
+    [Fact]
+    public void Validate_Prime_MatchesBatch()
+    {
+        const int period = 25;
+
+        var (bMid, bUp, bLo) = Fcb.Batch(_testData.Bars, period);
+
+        var primed = new Fcb(period);
+        var subset = new TBarSeries();
+        for (int i = 0; i < 200; i++)
+        {
+            subset.Add(_testData.Bars[i]);
+        }
+
+        primed.Prime(subset);
+
+        for (int i = 200; i < _testData.Bars.Count; i++)
+        {
+            primed.Update(_testData.Bars[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("FCB Prime validated against batch");
+    }
+
+    [Fact]
+    public void Validate_LargeDataset_FiniteOutputs()
+    {
+        var (mid, up, lo) = Fcb.Batch(_testData.Bars, 50);
+
+        ValidationHelper.VerifyAllFinite(mid, startIndex: 0);
+        ValidationHelper.VerifyAllFinite(up, startIndex: 0);
+        ValidationHelper.VerifyAllFinite(lo, startIndex: 0);
+
+        // After warmup, upper should always be >= lower
+        int warmup = 50 + 2; // period + 2 for fractal detection
+        for (int i = warmup; i < mid.Count; i++)
+        {
+            Assert.True(up[i].Value >= lo[i].Value, $"Upper >= Lower at {i}");
+        }
+
+        _output.WriteLine("FCB large dataset validated");
+    }
+
+    [Fact]
+    public void Validate_FractalPattern_CorrectDetection()
+    {
+        // Create a series with known fractal patterns
+        var series = new TBarSeries();
+        var t0 = DateTime.UtcNow;
+
+        // Pattern designed to have clear fractals:
+        // highs: 100, 110, 105 -> fractal high at index 1 = 110
+        // lows:   50,  45,  48 -> fractal low at index 1 = 45
+        double[] highs = { 100, 110, 105, 108, 115, 112, 118, 125, 120 };
+        double[] lows = { 50, 45, 48, 42, 47, 40, 44, 38, 42 };
+
+        for (int i = 0; i < highs.Length; i++)
+        {
+            series.Add(new TBar(t0.AddMinutes(i), 0, highs[i], lows[i], (highs[i] + lows[i]) / 2, 100));
+        }
+
+        var ind = new Fcb(5);
+        var (mid, up, lo) = ind.Update(series);
+
+        // All outputs should be finite
+        for (int i = 0; i < series.Count; i++)
+        {
+            Assert.True(double.IsFinite(mid[i].Value), $"Mid finite at {i}");
+            Assert.True(double.IsFinite(up[i].Value), $"Upper finite at {i}");
+            Assert.True(double.IsFinite(lo[i].Value), $"Lower finite at {i}");
+        }
+
+        // After enough bars, upper should be >= lower
+        for (int i = 3; i < series.Count; i++)
+        {
+            Assert.True(up[i].Value >= lo[i].Value, $"Upper >= Lower at {i}");
+        }
+
+        _output.WriteLine("FCB fractal pattern validation passed");
+    }
+
+    [Fact]
+    public void Validate_MiddleIsAverage_AllBars()
+    {
+        var ind = new Fcb(20);
+        var (mid, up, lo) = ind.Update(_testData.Bars);
+
+        for (int i = 0; i < mid.Count; i++)
+        {
+            double expected = (up[i].Value + lo[i].Value) * 0.5;
+            Assert.Equal(expected, mid[i].Value, 1e-10);
+        }
+
+        _output.WriteLine("FCB middle = average validated for all bars");
+    }
+
+    [Fact]
+    public void Validate_BandsAreMonotonic_WithinWindow()
+    {
+        // The upper band should be the highest fractal high in the window
+        // The lower band should be the lowest fractal low in the window
+        // These values shouldn't jump erratically unless new fractals are detected
+
+        var ind = new Fcb(10);
+        foreach (var bar in _testData.Bars)
+        {
+            ind.Update(bar);
+
+            // Upper should always be >= Lower
+            if (ind.IsHot)
+            {
+                Assert.True(ind.Upper.Value >= ind.Lower.Value,
+                    $"Upper ({ind.Upper.Value}) should be >= Lower ({ind.Lower.Value})");
+            }
+        }
+
+        _output.WriteLine("FCB band monotonicity validated");
+    }
+}
@@ -0,0 +1,492 @@
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// FCB: Fractal Chaos Bands
+/// Tracks the highest fractal high and lowest fractal low over a lookback period.
+/// A fractal high occurs when high[1] > high[0] and high[1] > high[2] (3-bar pattern).
+/// A fractal low occurs when low[1] < low[0] and low[1] < low[2] (3-bar pattern).
+/// Uses monotonic deques for O(1) amortized complexity.
+/// </summary>
+[SkipLocalsInit]
+public sealed class Fcb : ITValuePublisher
+{
+    private readonly int _period;
+
+    // Circular buffers for fractal values
+    private readonly double[] _hBuf;
+    private readonly double[] _lBuf;
+
+    // Monotonic deques (store indices)
+    private readonly int[] _hDeque;
+    private readonly int[] _lDeque;
+
+    // Deque state
+    private int _hHead;
+    private int _hCount;
+    private int _lHead;
+    private int _lCount;
+
+    // Rolling counters
+    private int _count;
+    private long _index;
+
+    [StructLayout(LayoutKind.Auto)]
+    private record struct State(
+        double High0, double High1, double High2,
+        double Low0, double Low1, double Low2,
+        double HiFractal, double LoFractal,
+        double LastValidHigh, double LastValidLow,
+        bool IsHot);
+
+    private State _state;
+    private State _p_state;
+
+    private readonly TBarPublishedHandler _barHandler;
+
+    public string Name { get; }
+    public int WarmupPeriod { get; }
+    public TValue Last { get; private set; }
+    public TValue Upper { get; private set; }
+    public TValue Lower { get; private set; }
+    public bool IsHot => _state.IsHot;
+
+    public event TValuePublishedHandler? Pub;
+
+    public Fcb(int period = 20)
+    {
+        if (period < 1)
+            throw new ArgumentOutOfRangeException(nameof(period), "Period must be >= 1.");
+
+        _period = period;
+        WarmupPeriod = period + 2; // Need 2 extra bars for fractal detection
+
+        _hBuf = new double[_period];
+        _lBuf = new double[_period];
+        _hDeque = new int[_period];
+        _lDeque = new int[_period];
+
+        Name = $"Fcb({period})";
+        _barHandler = HandleBar;
+
+        Reset();
+    }
+
+    public Fcb(TBarSeries source, int period = 20) : this(period)
+    {
+        Prime(source);
+        source.Pub += _barHandler;
+    }
+
+    private void HandleBar(object? sender, in TBarEventArgs 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)]
+    private (double high, double low) GetValid(double high, double low)
+    {
+        if (double.IsFinite(high))
+            _state = _state with { LastValidHigh = high };
+        else
+            high = _state.LastValidHigh;
+
+        if (double.IsFinite(low))
+            _state = _state with { LastValidLow = low };
+        else
+            low = _state.LastValidLow;
+
+        return (high, low);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void PushMax(long logicalIndex, double value)
+    {
+        // Expire old indices
+        long expire = logicalIndex - _period;
+        while (_hCount > 0 && _hDeque[_hHead] <= expire)
+        {
+            _hHead = (_hHead + 1) % _period;
+            _hCount--;
+        }
+
+        // Maintain monotonic non-increasing deque
+        while (_hCount > 0)
+        {
+            int backIdx = (_hHead + _hCount - 1) % _period;
+            int bufIdx = _hDeque[backIdx] % _period;
+            if (_hBuf[bufIdx] <= value)
+                _hCount--;
+            else
+                break;
+        }
+
+        int tail = (_hHead + _hCount) % _period;
+        _hDeque[tail] = (int)logicalIndex;
+        _hCount++;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void PushMin(long logicalIndex, double value)
+    {
+        long expire = logicalIndex - _period;
+        while (_lCount > 0 && _lDeque[_lHead] <= expire)
+        {
+            _lHead = (_lHead + 1) % _period;
+            _lCount--;
+        }
+
+        while (_lCount > 0)
+        {
+            int backIdx = (_lHead + _lCount - 1) % _period;
+            int bufIdx = _lDeque[backIdx] % _period;
+            if (_lBuf[bufIdx] >= value)
+                _lCount--;
+            else
+                break;
+        }
+
+        int tail = (_lHead + _lCount) % _period;
+        _lDeque[tail] = (int)logicalIndex;
+        _lCount++;
+    }
+
+    private void RebuildDeques()
+    {
+        _hHead = 0;
+        _lHead = 0;
+        _hCount = 0;
+        _lCount = 0;
+
+        if (_count == 0)
+            return;
+
+        long startLogical = _index - _count + 1;
+        for (int i = 0; i < _count; i++)
+        {
+            long logicalIndex = startLogical + i;
+            int bufIdx = (int)(logicalIndex % _period);
+            double h = _hBuf[bufIdx];
+            double l = _lBuf[bufIdx];
+            PushMax(logicalIndex, h);
+            PushMin(logicalIndex, l);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Reset()
+    {
+        Array.Clear(_hBuf);
+        Array.Clear(_lBuf);
+        _hHead = 0;
+        _lHead = 0;
+        _hCount = 0;
+        _lCount = 0;
+        _count = 0;
+        _index = -1;
+        _state = new State(0, 0, 0, 0, 0, 0, double.NaN, double.NaN, double.NaN, double.NaN, false);
+        _p_state = _state;
+        Last = default;
+        Upper = default;
+        Lower = default;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TValue Update(TBar input, bool isNew = true)
+    {
+        if (isNew)
+            _p_state = _state;
+        else
+            _state = _p_state;
+
+        if (isNew)
+        {
+            _index++;
+            if (_count < _period)
+                _count++;
+        }
+
+        var (high, low) = GetValid(input.High, input.Low);
+
+        // Shift high/low history
+        _state = _state with
+        {
+            High2 = _state.High1,
+            High1 = _state.High0,
+            High0 = high,
+            Low2 = _state.Low1,
+            Low1 = _state.Low0,
+            Low0 = low
+        };
+
+        // Initialize fractal values on first bar
+        if (_index == 0)
+        {
+            _state = _state with
+            {
+                HiFractal = high,
+                LoFractal = low
+            };
+        }
+
+        // Detect fractals (need at least 3 bars: indices 0, 1, 2 means _index >= 2)
+        if (_index >= 2)
+        {
+            // Fractal high: high[1] > high[2] and high[1] > high[0]
+            if (_state.High1 > _state.High2 && _state.High1 > _state.High0)
+            {
+                _state = _state with { HiFractal = _state.High1 };
+            }
+
+            // Fractal low: low[1] < low[2] and low[1] < low[0]
+            if (_state.Low1 < _state.Low2 && _state.Low1 < _state.Low0)
+            {
+                _state = _state with { LoFractal = _state.Low1 };
+            }
+        }
+
+        // Handle invalid fractal values (shouldn't happen after warmup)
+        double hiFrac = double.IsFinite(_state.HiFractal) ? _state.HiFractal : high;
+        double loFrac = double.IsFinite(_state.LoFractal) ? _state.LoFractal : low;
+
+        int bufIdx = (int)(_index % _period);
+        _hBuf[bufIdx] = hiFrac;
+        _lBuf[bufIdx] = loFrac;
+
+        if (isNew)
+        {
+            PushMax(_index, hiFrac);
+            PushMin(_index, loFrac);
+        }
+        else
+        {
+            RebuildDeques();
+        }
+
+        double top = _hBuf[_hDeque[_hHead] % _period];
+        double bot = _lBuf[_lDeque[_lHead] % _period];
+        double mid = (top + bot) * 0.5;
+
+        if (!_state.IsHot && _index + 1 >= WarmupPeriod)
+            _state = _state with { IsHot = true };
+
+        Last = new TValue(input.Time, mid);
+        Upper = new TValue(input.Time, top);
+        Lower = new TValue(input.Time, bot);
+
+        PubEvent(Last, isNew);
+        return Last;
+    }
+
+    public (TSeries Middle, TSeries Upper, TSeries Lower) Update(TBarSeries 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.HighValues, source.LowValues, vMiddleSpan, vUpperSpan, vLowerSpan, _period);
+
+        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(TBarSeries 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 (zero allocation).
+    /// </summary>
+    public static void Batch(
+        ReadOnlySpan<double> high,
+        ReadOnlySpan<double> low,
+        Span<double> middle,
+        Span<double> upper,
+        Span<double> lower,
+        int period)
+    {
+        if (period < 1)
+            throw new ArgumentOutOfRangeException(nameof(period), "Period must be >= 1.");
+        if (high.Length != low.Length)
+            throw new ArgumentException("High and Low spans must have the same length", nameof(high));
+        if (middle.Length < high.Length || upper.Length < high.Length || lower.Length < high.Length)
+            throw new ArgumentException("Output spans must be at least as long as inputs", nameof(middle));
+
+        int len = high.Length;
+        if (len == 0) return;
+
+        // Allocate buffers for fractal tracking and deques
+        double[] hBuf = ArrayPool<double>.Shared.Rent(period);
+        double[] lBuf = ArrayPool<double>.Shared.Rent(period);
+        int[] hDeque = ArrayPool<int>.Shared.Rent(period);
+        int[] lDeque = ArrayPool<int>.Shared.Rent(period);
+
+        try
+        {
+            int hHead = 0, hCount = 0;
+            int lHead = 0, lCount = 0;
+
+            double h0 = 0, h1 = 0, h2 = 0;
+            double l0 = 0, l1 = 0, l2 = 0;
+            double hiFractal = high[0];
+            double loFractal = low[0];
+
+            for (int i = 0; i < len; i++)
+            {
+                // Shift history
+                h2 = h1;
+                h1 = h0;
+                h0 = high[i];
+
+                l2 = l1;
+                l1 = l0;
+                l0 = low[i];
+
+                // Detect fractals after 3 bars
+                if (i >= 2)
+                {
+                    if (h1 > h2 && h1 > h0)
+                        hiFractal = h1;
+                    if (l1 < l2 && l1 < l0)
+                        loFractal = l1;
+                }
+
+                int bufIdx = i % period;
+                hBuf[bufIdx] = hiFractal;
+                lBuf[bufIdx] = loFractal;
+
+                // Push to max deque
+                long expire = i - period;
+                while (hCount > 0 && hDeque[hHead] <= expire)
+                {
+                    hHead = (hHead + 1) % period;
+                    hCount--;
+                }
+                while (hCount > 0)
+                {
+                    int backIdx = (hHead + hCount - 1) % period;
+                    int bIdx = hDeque[backIdx] % period;
+                    if (hBuf[bIdx] <= hiFractal)
+                        hCount--;
+                    else
+                        break;
+                }
+                int tail = (hHead + hCount) % period;
+                hDeque[tail] = i;
+                hCount++;
+
+                // Push to min deque
+                while (lCount > 0 && lDeque[lHead] <= expire)
+                {
+                    lHead = (lHead + 1) % period;
+                    lCount--;
+                }
+                while (lCount > 0)
+                {
+                    int backIdx = (lHead + lCount - 1) % period;
+                    int bIdx = lDeque[backIdx] % period;
+                    if (lBuf[bIdx] >= loFractal)
+                        lCount--;
+                    else
+                        break;
+                }
+                tail = (lHead + lCount) % period;
+                lDeque[tail] = i;
+                lCount++;
+
+                double top = hBuf[hDeque[hHead] % period];
+                double bot = lBuf[lDeque[lHead] % period];
+                upper[i] = top;
+                lower[i] = bot;
+                middle[i] = (top + bot) * 0.5;
+            }
+        }
+        finally
+        {
+            ArrayPool<double>.Shared.Return(hBuf);
+            ArrayPool<double>.Shared.Return(lBuf);
+            ArrayPool<int>.Shared.Return(hDeque);
+            ArrayPool<int>.Shared.Return(lDeque);
+        }
+    }
+
+    public static (TSeries Middle, TSeries Upper, TSeries Lower) Batch(TBarSeries source, int period = 20)
+    {
+        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.HighValues, source.LowValues,
+            CollectionsMarshal.AsSpan(vMiddle),
+            CollectionsMarshal.AsSpan(vUpper),
+            CollectionsMarshal.AsSpan(vLower),
+            period);
+
+        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, Fcb Indicator) Calculate(TBarSeries source, int period = 20)
+    {
+        var indicator = new Fcb(source, period);
+        var results = indicator.Update(source);
+        return (results, indicator);
+    }
+}
@@ -0,0 +1,195 @@
+# FCB: Fractal Chaos Bands
+
+> "The market speaks through fractals—moments when price definitively says 'this high matters' or 'this low counts.' Everything else is noise."
+
+Fractal Chaos Bands (FCB) track the highest fractal high and lowest fractal low over a lookback period. Unlike Donchian Channels that use raw price extremes, FCB filters for *significant* turning points—three-bar patterns where the middle bar's high exceeds both neighbors (fractal high) or the middle bar's low undercuts both neighbors (fractal low). The result: bands that represent confirmed support and resistance levels rather than transient spikes.
+
+## Historical Context
+
+The concept of fractals in trading traces back to Bill Williams' work in the 1990s, published in "Trading Chaos" (1995) and "New Trading Dimensions" (1998). Williams defined fractal highs and lows as five-bar patterns, but the three-bar variant has become more common in modern implementations due to its faster response.
+
+The three-bar fractal definition originates from chaos theory principles: a local maximum or minimum surrounded by lower or higher values represents a point where market sentiment definitively shifted. These aren't just any highs and lows—they're *confirmed* turning points where buyers or sellers demonstrated clear dominance.
+
+Most fractal band implementations store fractals in lists and rescan for max/min on each bar. QuanTAlib uses monotonic deques that maintain running max/min of fractal values in O(1) amortized time, enabling real-time feeds without performance degradation.
+
+## Architecture & Physics
+
+Fractal Chaos Bands consist of three components: fractal detection, band tracking via monotonic deques, and the middle band calculation.
+
+### 1. Fractal High Detection
+
+A fractal high occurs when the previous bar's high exceeds both its neighbors:
+
+$$
+\text{FractalHigh}_t = \begin{cases}
+H_{t-1} & \text{if } H_{t-1} > H_{t-2} \text{ and } H_{t-1} > H_t \\
+\text{FractalHigh}_{t-1} & \text{otherwise}
+\end{cases}
+$$
+
+where $H$ is the high price. The fractal is detected on bar $t$ but refers to the price at bar $t-1$ (the middle bar of the three-bar pattern).
+
+### 2. Fractal Low Detection
+
+A fractal low occurs when the previous bar's low undercuts both its neighbors:
+
+$$
+\text{FractalLow}_t = \begin{cases}
+L_{t-1} & \text{if } L_{t-1} < L_{t-2} \text{ and } L_{t-1} < L_t \\
+\text{FractalLow}_{t-1} & \text{otherwise}
+\end{cases}
+$$
+
+where $L$ is the low price. Like fractal highs, this is confirmed one bar later.
+
+### 3. Upper Band (Highest Fractal High)
+
+Tracks the maximum fractal high value over the lookback window:
+
+$$
+U_t = \max_{i=0}^{n-1}(\text{FractalHigh}_{t-i})
+$$
+
+The upper band represents the highest *confirmed* resistance level within the period.
+
+### 4. Lower Band (Lowest Fractal Low)
+
+Tracks the minimum fractal low value over the lookback window:
+
+$$
+L_t = \min_{i=0}^{n-1}(\text{FractalLow}_{t-i})
+$$
+
+The lower band represents the lowest *confirmed* support level within the period.
+
+### 5. Middle Band
+
+The arithmetic mean of the upper and lower bands:
+
+$$
+M_t = \frac{U_t + L_t}{2}
+$$
+
+This represents the equilibrium between confirmed support and resistance.
+
+## Mathematical Foundation
+
+### Three-Bar Fractal Pattern
+
+The three-bar fractal pattern requires strict inequality:
+
+**Fractal High at index $i$:**
+$$
+H_i > H_{i-1} \quad \text{AND} \quad H_i > H_{i+1}
+$$
+
+**Fractal Low at index $i$:**
+$$
+L_i < L_{i-1} \quad \text{AND} \quad L_i < L_{i+1}
+$$
+
+Note: The fractal at index $i$ is only *detected* when bar $i+1$ arrives, introducing a one-bar confirmation delay.
+
+### Monotonic Deque Algorithm
+
+The implementation maintains two monotonic deques for fractal values (not raw prices):
+
+**For maximum (upper band):**
+
+1. On new fractal high: remove smaller values from deque back, add new value
+2. On each bar: expire indices outside the lookback window
+3. Front element is always the maximum fractal high
+
+**For minimum (lower band):**
+
+1. On new fractal low: remove larger values from deque back, add new value
+2. On each bar: expire indices outside the lookback window
+3. Front element is always the minimum fractal low
+
+**Complexity**: O(1) amortized per bar.
+
+### Warmup Period
+
+FCB requires $\text{period} + 2$ bars for full warmup:
+
+- 2 bars for fractal detection (need bars 0, 1, 2 to detect fractal at bar 1)
+- Period bars for the sliding window to fill
+
+## Performance Profile
+
+### Operation Count (Streaming Mode, Scalar)
+
+Per-bar cost includes fractal detection plus deque updates:
+
+| Operation | Count | Cost (cycles) | Subtotal |
+| :--- | :---: | :---: | :---: |
+| CMP (fractal detection) | 4 | 1 | 4 |
+| CMP (deque maintenance) | 4 | 1 | 4 |
+| ADD | 1 | 1 | 1 |
+| MUL | 1 | 3 | 3 |
+| **Total** | **10** | — | **~12 cycles** |
+
+**Complexity**: O(1) amortized per bar.
+
+### Batch Mode (512 values, SIMD/FMA)
+
+Fractal detection is inherently sequential (depends on neighbors). Limited SIMD benefit:
+
+| Operation | Scalar Ops | SIMD Benefit | Notes |
+| :--- | :---: | :---: | :--- |
+| Fractal detection | 4 | 1× | Sequential dependency |
+| Deque maintenance | 4 | 1× | Sequential dependency |
+| Middle band | 2 | 2× | Parallelizable |
+
+**Batch efficiency (512 bars):**
+
+| Mode | Cycles/bar | Total (512 bars) | Improvement |
+| :--- | :---: | :---: | :---: |
+| Scalar streaming | 12 | 6,144 | — |
+| Partial SIMD | ~11 | ~5,632 | **~8%** |
+
+The algorithm is already efficient; sequential dependencies limit SIMD gains.
+
+### Quality Metrics
+
+| Metric | Score | Notes |
+| :--- | :---: | :--- |
+| **Accuracy** | 10/10 | Exact fractal detection and max/min calculation |
+| **Timeliness** | 5/10 | One-bar confirmation delay plus lookback lag |
+| **Overshoot** | 10/10 | No overshoot—bands are actual fractal price levels |
+| **Smoothness** | 6/10 | Bands move in steps as new fractals form or old ones exit |
+
+## Validation
+
+| Library | Status | Notes |
+| :--- | :---: | :--- |
+| **TA-Lib** | N/A | No FCB implementation |
+| **Skender** | N/A | No FCB implementation |
+| **Tulip** | N/A | No FCB implementation |
+| **Ooples** | N/A | No FCB implementation |
+| **PineScript** | ✅ | Reference implementation match |
+
+FCB is not widely implemented in standard libraries. Validation is performed against the reference PineScript algorithm and internal consistency checks (batch vs. streaming vs. span mode parity).
+
+## Common Pitfalls
+
+1. **Confirmation Delay**: Fractals are confirmed one bar *after* they form. A fractal high at bar 10 is only detected when bar 11 arrives. Don't expect the upper band to update immediately on a new high—it must first be confirmed as a fractal.
+
+2. **No Fractal, No Update**: If price moves monotonically (no three-bar reversal pattern), no new fractals form, and bands remain static. This isn't a bug—it means there are no confirmed turning points. Extended trends can produce long periods of unchanging bands.
+
+3. **Warmup Period**: FCB requires `period + 2` bars before `IsHot` becomes true. The extra 2 bars account for fractal detection. Using the indicator before warmup produces bands based on initial (possibly unconfirmed) values.
+
+4. **Different from Donchian**: Donchian uses raw highs and lows; FCB uses fractal highs and lows. FCB bands are typically *inside* Donchian bands because fractals filter out transient spikes. Don't expect them to match.
+
+5. **Five-Bar vs. Three-Bar**: Williams' original fractals used five bars; this implementation uses three. Three-bar fractals are more responsive but less filtered. If you need the original Williams definition, this isn't it.
+
+6. **Memory Footprint**: The implementation stores separate buffers for fractal values and deque indices. For period=200, expect ~6.4 KB per instance (4 arrays × 200 elements × 8 bytes). For 5,000 symbols, budget ~32 MB.
+
+7. **Bar Correction (isNew=false)**: When correcting the current bar, the indicator rebuilds its deques from the stored fractal buffer. Frequent corrections are supported but trigger O(period) rebuilds. Minimize correction calls when possible.
+
+## References
+
+- Williams, B. M. (1995). *Trading Chaos: Applying Expert Techniques to Maximize Your Profits*. Wiley.
+- Williams, B. M. (1998). *New Trading Dimensions: How to Profit from Chaos in Stocks, Bonds, and Commodities*. Wiley.
+- Mandelbrot, B. B. (1982). *The Fractal Geometry of Nature*. Freeman.
+- TradingView. (2024). "Fractal Chaos Bands." Pine Script Reference Manual.