SIMD Refactor: Merge simd-dev into dev (#55)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
Co-authored-by: aider (openrouter/anthropic/claude-sonnet-4) <aider@aider.chat>
Co-authored-by: Warp <agent@warp.dev>

lib/forecasts/_index.md

@@ -0,0 +1,36 @@
+# Forecasts
+
+> "Prediction is very difficult, especially about the future."  Niels Bohr
+
+Forecasting and predictive models. Unlike reactive indicators that smooth past data, forecasts attempt to project future values. Extrapolation is inherently uncertain. Use with appropriate skepticism and position sizing.
+
+## Indicator Status
+
+| Indicator | Full Name | Status | Description |
+| :--- | :--- | :---: | :--- |
+| [AFIRMA](lib/forecasts/afirma/Afirma.md) | Adaptive FIR Moving Average |  | Windowed sinc coefficients. Optimal frequency response. Can extrapolate. |
+| CFO | Chande Forecast Oscillator | =Ë | Percentage difference between price and linear regression forecast. |
+| MLP | Multilayer Perceptron | =Ë | Neural network regressor. Nonlinear pattern learning. |
+| TSF | Time Series Forecast | =Ë | Linear regression projected forward. Standard extrapolation. |
+
+**Status Key:**  Implemented | =Ë Planned
+
+## Selection Guide
+
+| Use Case | Recommended | Why |
+| :--- | :--- | :--- |
+| Smooth extrapolation | AFIRMA | FIR with extrapolation coefficients. Configurable lookahead. |
+| Linear trend projection | TSF | Simple, interpretable. Works when trend is linear. |
+| Forecast deviation | CFO | Shows when price diverges from linear forecast. |
+| Nonlinear patterns | MLP | Neural network learns complex relationships. Requires training. |
+
+## Forecasting Principles
+
+| Aspect | Reality | Implication |
+| :--- | :--- | :--- |
+| Extrapolation risk | Markets are non-stationary | Short horizons more reliable |
+| Model uncertainty | All models are wrong | Use ensemble or confidence intervals |
+| Regime changes | Past patterns may not repeat | Monitor forecast errors |
+| Overfitting | Complex models fit noise | Prefer simple models when possible |
+
+Forecasting is not prediction. It is disciplined extrapolation of patterns that may or may not persist.

lib/forecasts/afirma/Afirma.Quantower.Tests.cs

@@ -0,0 +1,192 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class AfirmaIndicatorTests
+{
+    [Fact]
+    public void AfirmaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new AfirmaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(Afirma.WindowType.BlackmanHarris, indicator.Window);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("AFIRMA - Autoregressive FIR Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void AfirmaIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new AfirmaIndicator { Period = 20 };
+
+        Assert.Equal(0, AfirmaIndicator.MinHistoryDepths);
+        Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void AfirmaIndicator_ShortName_IncludesParameters()
+    {
+        var indicator = new AfirmaIndicator { Period = 15 };
+
+        Assert.Contains("AFIRMA", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("15", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AfirmaIndicator_Initialize_CreatesInternalAfirma()
+    {
+        var indicator = new AfirmaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void AfirmaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new AfirmaIndicator { Period = 5 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void AfirmaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new AfirmaIndicator { Period = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void AfirmaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new AfirmaIndicator { Period = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void AfirmaIndicator_MultipleUpdates_ProducesCorrectSequence()
+    {
+        var indicator = new AfirmaIndicator { Period = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105, 107, 106, 108 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+    }
+
+    [Fact]
+    public void AfirmaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new AfirmaIndicator { Period = 5, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void AfirmaIndicator_DifferentWindowTypes_Work()
+    {
+        var windows = new[]
+        {
+            Afirma.WindowType.Rectangular,
+            Afirma.WindowType.Hanning,
+            Afirma.WindowType.Hamming,
+            Afirma.WindowType.Blackman,
+            Afirma.WindowType.BlackmanHarris,
+        };
+
+        foreach (var window in windows)
+        {
+            var indicator = new AfirmaIndicator { Period = 5, Window = window };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Window {window} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void AfirmaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new AfirmaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+    }
+
+    [Fact]
+    public void AfirmaIndicator_Window_CanBeChanged()
+    {
+        var indicator = new AfirmaIndicator { Window = Afirma.WindowType.Hanning };
+        Assert.Equal(Afirma.WindowType.Hanning, indicator.Window);
+
+        indicator.Window = Afirma.WindowType.Blackman;
+        Assert.Equal(Afirma.WindowType.Blackman, indicator.Window);
+    }
+}

lib/forecasts/afirma/Afirma.Quantower.cs

@@ -0,0 +1,61 @@
+using System.Drawing;
+using System.Runtime.CompilerServices;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib;
+
+[SkipLocalsInit]
+public sealed class AfirmaIndicator : Indicator, IWatchlistIndicator
+{
+    [InputParameter("Period", sortIndex: 1, 1, 2000, 1, 0)]
+    public int Period { get; set; } = 10;
+
+    [InputParameter("Window", sortIndex: 3)]
+    public Afirma.WindowType Window { get; set; } = Afirma.WindowType.BlackmanHarris;
+
+    [InputParameter("Use Least Squares", sortIndex: 4)]
+    public bool LeastSquares { get; set; } = false;
+
+    [IndicatorExtensions.DataSourceInput]
+    public SourceType Source { get; set; } = SourceType.Close;
+
+    [InputParameter("Show cold values", sortIndex: 21)]
+    public bool ShowColdValues { get; set; } = true;
+
+    private Afirma _afirma = null!;
+    private readonly LineSeries _series;
+    private string _sourceName = null!;
+    private Func<IHistoryItem, double> _priceSelector = null!;
+
+    public static int MinHistoryDepths => 0;
+    int IWatchlistIndicator.MinHistoryDepths => MinHistoryDepths;
+
+    public override string ShortName => $"AFIRMA {Period}:{_sourceName}";
+
+    public AfirmaIndicator()
+    {
+        OnBackGround = true;
+        SeparateWindow = false;
+        Name = "AFIRMA - Autoregressive FIR Moving Average";
+        Description = "A Windowed Weighted Moving Average using signal processing window functions";
+        _series = new LineSeries(name: $"AFIRMA {Period}", color: IndicatorExtensions.Averages, width: 2, style: LineStyle.Solid);
+        AddLineSeries(_series);
+    }
+
+    protected override void OnInit()
+    {
+        _priceSelector = Source.GetPriceSelector();
+        _sourceName = Source.ToString();
+        _afirma = new Afirma(Period, Window, LeastSquares);
+        base.OnInit();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override void OnUpdate(UpdateArgs args)
+    {
+        bool isNew = args.IsNewBar();
+        var item = HistoricalData[Count - 1, SeekOriginHistory.Begin];
+        double value = _afirma.Update(new TValue(item.TimeLeft.Ticks, _priceSelector(item)), isNew).Value;
+        _series.SetValue(value, _afirma.IsHot, ShowColdValues);
+    }
+}

lib/forecasts/afirma/Afirma.Tests.cs

@@ -0,0 +1,651 @@
+namespace QuanTAlib.Tests;
+
+public class AfirmaTests
+{
+    [Fact]
+    public void Afirma_Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentException>(() => new Afirma(0));
+        Assert.Throws<ArgumentException>(() => new Afirma(-1));
+
+        var afirma = new Afirma(10);
+        Assert.NotNull(afirma);
+    }
+
+    [Fact]
+    public void Afirma_Constructor_AcceptsValidParameters()
+    {
+        var afirma1 = new Afirma(1);
+        Assert.NotNull(afirma1);
+
+        var afirma2 = new Afirma(10, Afirma.WindowType.Blackman);
+        Assert.NotNull(afirma2);
+
+        var afirma3 = new Afirma(5, Afirma.WindowType.Rectangular);
+        Assert.NotNull(afirma3);
+
+        var afirma4 = new Afirma(10, Afirma.WindowType.BlackmanHarris, leastSquares: true);
+        Assert.NotNull(afirma4);
+    }
+
+    [Fact]
+    public void Afirma_Calc_ReturnsValue()
+    {
+        var afirma = new Afirma(10);
+
+        Assert.Equal(0, afirma.Last.Value);
+
+        TValue result = afirma.Update(new TValue(DateTime.UtcNow, 100));
+
+        Assert.True(result.Value > 0);
+        Assert.Equal(result.Value, afirma.Last.Value);
+    }
+
+    [Fact]
+    public void Afirma_FirstValue_ReturnsValue()
+    {
+        var afirma = new Afirma(10);
+
+        TValue result = afirma.Update(new TValue(DateTime.UtcNow, 100));
+
+        // First value should be based on the single input
+        Assert.True(double.IsFinite(result.Value));
+        Assert.True(result.Value > 0);
+    }
+
+    [Fact]
+    public void Afirma_LeastSquares_AffectsResult()
+    {
+        // Generate trend data where LS regression should differ from raw window
+        var gbm = new GBM(startPrice: 100.0, mu: 0.05, sigma: 0.01, seed: 42);
+        var data = new List<TValue>();
+        for (int i = 0; i < 20; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            data.Add(new TValue(bar.Time, bar.Close));
+        }
+
+        var afirmaDefault = new Afirma(10, Afirma.WindowType.BlackmanHarris, leastSquares: false);
+        var afirmaLS = new Afirma(10, Afirma.WindowType.BlackmanHarris, leastSquares: true);
+
+        double lastDefault = 0;
+        double lastLS = 0;
+
+        foreach (var item in data)
+        {
+            lastDefault = afirmaDefault.Update(item).Value;
+            lastLS = afirmaLS.Update(item).Value;
+        }
+
+        // They should be different
+        Assert.NotEqual(lastDefault, lastLS, 1e-6);
+        Assert.True(double.IsFinite(lastLS));
+    }
+
+    [Fact]
+    public void Afirma_LeastSquares_HandlesNaN()
+    {
+        var afirma = new Afirma(10, Afirma.WindowType.BlackmanHarris, leastSquares: true);
+
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        afirma.Update(new TValue(DateTime.UtcNow, 110));
+
+        // Feed NaN - should handle gracefully (typically carries forward last valid or handles via regression on existing points)
+        var result = afirma.Update(new TValue(DateTime.UtcNow, double.NaN));
+
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Afirma_Calc_IsNew_AcceptsParameter()
+    {
+        var afirma = new Afirma(10);
+
+        afirma.Update(new TValue(DateTime.UtcNow, 100), isNew: true);
+        double value1 = afirma.Last.Value;
+
+        afirma.Update(new TValue(DateTime.UtcNow, 200), isNew: true);
+        double value2 = afirma.Last.Value;
+
+        // Values should change with new bars
+        Assert.NotEqual(value1, value2);
+    }
+
+    [Fact]
+    public void Afirma_Calc_IsNew_False_UpdatesValue()
+    {
+        var afirma = new Afirma(10);
+
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        afirma.Update(new TValue(DateTime.UtcNow, 110), isNew: true);
+        double beforeUpdate = afirma.Last.Value;
+
+        afirma.Update(new TValue(DateTime.UtcNow, 120), isNew: false);
+        double afterUpdate = afirma.Last.Value;
+
+        // Update should change the value
+        Assert.NotEqual(beforeUpdate, afterUpdate);
+    }
+
+    [Fact]
+    public void Afirma_Reset_ClearsState()
+    {
+        var afirma = new Afirma(10);
+
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        afirma.Update(new TValue(DateTime.UtcNow, 105));
+        double valueBefore = afirma.Last.Value;
+
+        afirma.Reset();
+
+        Assert.Equal(0, afirma.Last.Value);
+
+        // After reset, should accept new values
+        afirma.Update(new TValue(DateTime.UtcNow, 50));
+        Assert.NotEqual(0, afirma.Last.Value);
+        Assert.NotEqual(valueBefore, afirma.Last.Value);
+    }
+
+    [Fact]
+    public void Afirma_Properties_Accessible()
+    {
+        var afirma = new Afirma(10);
+
+        Assert.Equal(0, afirma.Last.Value);
+        Assert.False(afirma.IsHot);
+
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+
+        Assert.NotEqual(0, afirma.Last.Value);
+    }
+
+    [Fact]
+    public void Afirma_IsHot_BecomesTrueWhenBufferFull()
+    {
+        var afirma = new Afirma(5);
+
+        Assert.False(afirma.IsHot);
+
+        for (int i = 1; i <= 4; i++)
+        {
+            afirma.Update(new TValue(DateTime.UtcNow, i * 10));
+            Assert.False(afirma.IsHot);
+        }
+
+        afirma.Update(new TValue(DateTime.UtcNow, 50));
+        Assert.True(afirma.IsHot);
+    }
+
+    [Fact]
+    public void Afirma_IterativeCorrections_RestoreToOriginalState()
+    {
+        var afirma = new Afirma(5);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+
+        // Feed 10 new values
+        TValue tenthInput = default;
+        for (int i = 0; i < 10; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            tenthInput = new TValue(bar.Time, bar.Close);
+            afirma.Update(tenthInput, isNew: true);
+        }
+
+        // Remember state after 10 values
+        double stateAfterTen = afirma.Last.Value;
+
+        // Generate 9 corrections with isNew=false (different values)
+        for (int i = 0; i < 9; i++)
+        {
+            var bar = gbm.Next(isNew: false);
+            afirma.Update(new TValue(bar.Time, bar.Close), isNew: false);
+        }
+
+        // Feed the remembered 10th input again with isNew=false
+        TValue finalResult = afirma.Update(tenthInput, isNew: false);
+
+        // State should match the original state after 10 values
+        Assert.Equal(stateAfterTen, finalResult.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Afirma_BatchCalc_MatchesIterativeCalc()
+    {
+        var afirmaIterative = new Afirma(10);
+        var afirmaBatch = new Afirma(10);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+
+        // Generate data
+        var series = new TSeries();
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            series.Add(bar.Time, bar.Close);
+        }
+
+        Assert.True(series.Count > 0);
+
+        // Calculate iteratively
+        var iterativeResults = new TSeries();
+        foreach (var item in series)
+        {
+            iterativeResults.Add(afirmaIterative.Update(item));
+        }
+
+        // Calculate batch
+        var batchResults = afirmaBatch.Update(series);
+
+        // Compare
+        Assert.Equal(iterativeResults.Count, batchResults.Count);
+        for (int i = 0; i < iterativeResults.Count; i++)
+        {
+            Assert.Equal(iterativeResults[i].Value, batchResults[i].Value, 1e-10);
+            Assert.Equal(iterativeResults[i].Time, batchResults[i].Time);
+        }
+    }
+
+    [Fact]
+    public void Afirma_NaN_Input_UsesLastValidValue()
+    {
+        var afirma = new Afirma(10);
+
+        // Feed some valid values
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        afirma.Update(new TValue(DateTime.UtcNow, 110));
+
+        // Feed NaN - should use last valid value
+        var resultAfterNaN = afirma.Update(new TValue(DateTime.UtcNow, double.NaN));
+
+        // Result should be finite (not NaN)
+        Assert.True(double.IsFinite(resultAfterNaN.Value));
+        Assert.NotEqual(0, resultAfterNaN.Value);
+    }
+
+    [Fact]
+    public void Afirma_Infinity_Input_UsesLastValidValue()
+    {
+        var afirma = new Afirma(10);
+
+        // Feed some valid values
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        afirma.Update(new TValue(DateTime.UtcNow, 110));
+
+        // Feed positive infinity - should use last valid value
+        var resultAfterPosInf = afirma.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity));
+        Assert.True(double.IsFinite(resultAfterPosInf.Value));
+
+        // Feed negative infinity - should use last valid value
+        var resultAfterNegInf = afirma.Update(new TValue(DateTime.UtcNow, double.NegativeInfinity));
+        Assert.True(double.IsFinite(resultAfterNegInf.Value));
+    }
+
+    [Fact]
+    public void Afirma_MultipleNaN_ContinuesWithLastValid()
+    {
+        var afirma = new Afirma(10);
+
+        // Feed valid values
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        afirma.Update(new TValue(DateTime.UtcNow, 110));
+        afirma.Update(new TValue(DateTime.UtcNow, 120));
+
+        // Feed multiple NaN values
+        var r1 = afirma.Update(new TValue(DateTime.UtcNow, double.NaN));
+        var r2 = afirma.Update(new TValue(DateTime.UtcNow, double.NaN));
+        var r3 = afirma.Update(new TValue(DateTime.UtcNow, double.NaN));
+
+        // All results should be finite
+        Assert.True(double.IsFinite(r1.Value));
+        Assert.True(double.IsFinite(r2.Value));
+        Assert.True(double.IsFinite(r3.Value));
+    }
+
+    [Fact]
+    public void Afirma_BatchCalc_HandlesNaN()
+    {
+        var afirma = new Afirma(10);
+
+        // Create series with NaN values interspersed
+        var series = new TSeries();
+        series.Add(DateTime.UtcNow.Ticks, 100);
+        series.Add(DateTime.UtcNow.Ticks + 1, 110);
+        series.Add(DateTime.UtcNow.Ticks + 2, double.NaN);
+        series.Add(DateTime.UtcNow.Ticks + 3, 120);
+        series.Add(DateTime.UtcNow.Ticks + 4, double.PositiveInfinity);
+        series.Add(DateTime.UtcNow.Ticks + 5, 130);
+
+        var results = afirma.Update(series);
+
+        // All results should be finite
+        foreach (var result in results)
+        {
+            Assert.True(double.IsFinite(result.Value), $"Expected finite value but got {result.Value}");
+        }
+    }
+
+    [Fact]
+    public void Afirma_Reset_ClearsLastValidValue()
+    {
+        var afirma = new Afirma(10);
+
+        // Feed values including NaN
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        afirma.Update(new TValue(DateTime.UtcNow, double.NaN));
+
+        // Reset
+        afirma.Reset();
+
+        // After reset, first valid value should establish new baseline
+        var result = afirma.Update(new TValue(DateTime.UtcNow, 50));
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Afirma_StaticBatch_Works()
+    {
+        var series = new TSeries();
+        series.Add(DateTime.UtcNow.Ticks, 10);
+        series.Add(DateTime.UtcNow.Ticks + 1, 20);
+        series.Add(DateTime.UtcNow.Ticks + 2, 30);
+        series.Add(DateTime.UtcNow.Ticks + 3, 40);
+        series.Add(DateTime.UtcNow.Ticks + 4, 50);
+
+        var results = Afirma.Batch(series, 5);
+
+        Assert.Equal(5, results.Count);
+        Assert.True(double.IsFinite(results.Last.Value));
+    }
+
+    [Fact]
+    public void Afirma_Period1_ReturnsSmoothedValues()
+    {
+        var afirma = new Afirma(1);
+
+        var r1 = afirma.Update(new TValue(DateTime.UtcNow, 100));
+        var r2 = afirma.Update(new TValue(DateTime.UtcNow, 200));
+        var r3 = afirma.Update(new TValue(DateTime.UtcNow, 150));
+
+        Assert.True(double.IsFinite(r1.Value));
+        Assert.True(double.IsFinite(r2.Value));
+        Assert.True(double.IsFinite(r3.Value));
+    }
+
+    // ============== Span API Tests ==============
+
+    [Fact]
+    public void Afirma_SpanBatch_ValidatesInput()
+    {
+        double[] source = [1, 2, 3, 4, 5];
+        double[] output = new double[5];
+        double[] wrongSizeOutput = new double[3];
+
+        // Period must be >= 1
+        Assert.Throws<ArgumentException>(() => Afirma.Batch(source.AsSpan(), output.AsSpan(), 0));
+        Assert.Throws<ArgumentException>(() => Afirma.Batch(source.AsSpan(), output.AsSpan(), -1));
+
+        // Output must be same length as source
+        Assert.Throws<ArgumentException>(() => Afirma.Batch(source.AsSpan(), wrongSizeOutput.AsSpan(), 5));
+    }
+
+    [Fact]
+    public void Afirma_SpanBatch_MatchesTSeriesBatch()
+    {
+        var series = new TSeries();
+        double[] source = new double[100];
+        double[] output = new double[100];
+
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1, seed: 42);
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            source[i] = bar.Close;
+            series.Add(bar.Time, bar.Close);
+        }
+
+        // Calculate with TSeries API
+        var tseriesResult = Afirma.Batch(series, 10);
+
+        // Calculate with Span API
+        Afirma.Batch(source.AsSpan(), output.AsSpan(), 10);
+
+        // Compare results
+        for (int i = 0; i < 100; i++)
+        {
+            Assert.Equal(tseriesResult[i].Value, output[i], 1e-10);
+        }
+    }
+
+    [Fact]
+    public void Afirma_SpanBatch_CalculatesCorrectly()
+    {
+        double[] source = [10, 20, 30, 40, 50];
+        double[] output = new double[5];
+
+        Afirma.Batch(source.AsSpan(), output.AsSpan(), 5);
+
+        // All outputs should be finite
+        foreach (var val in output)
+        {
+            Assert.True(double.IsFinite(val), $"Expected finite value but got {val}");
+        }
+    }
+
+    [Fact]
+    public void Afirma_SpanBatch_ZeroAllocation()
+    {
+        double[] source = new double[10000];
+        double[] output = new double[10000];
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 42);
+        for (int i = 0; i < source.Length; i++)
+            source[i] = gbm.Next().Close;
+
+        // Warm up
+        Afirma.Batch(source.AsSpan(), output.AsSpan(), 10);
+
+        // This test verifies the method runs without throwing
+        Assert.True(double.IsFinite(output[^1]));
+    }
+
+    [Fact]
+    public void Afirma_SpanBatch_HandlesNaN()
+    {
+        double[] source = [100, 110, double.NaN, 120, 130];
+        double[] output = new double[5];
+
+        Afirma.Batch(source.AsSpan(), output.AsSpan(), 5);
+
+        // All outputs should be finite
+        foreach (var val in output)
+        {
+            Assert.True(double.IsFinite(val), $"Expected finite value but got {val}");
+        }
+    }
+
+    [Fact]
+    public void Afirma_AllModes_ProduceSameResult()
+    {
+        // Arrange
+        const int period = 10;
+        var window = Afirma.WindowType.BlackmanHarris;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // 1. Batch Mode
+        var batchSeries = Afirma.Batch(series, period, window);
+        double expected = batchSeries.Last.Value;
+
+        // 2. Span Mode
+        var tValues = series.Values.ToArray();
+        var spanInput = new ReadOnlySpan<double>(tValues);
+        var spanOutput = new double[tValues.Length];
+        Afirma.Batch(spanInput, spanOutput, period, window);
+        double spanResult = spanOutput[^1];
+
+        // 3. Streaming Mode
+        var streamingInd = new Afirma(period, window);
+        for (int i = 0; i < series.Count; i++)
+        {
+            streamingInd.Update(series[i]);
+        }
+        double streamingResult = streamingInd.Last.Value;
+
+        // 4. Eventing Mode
+        var pubSource = new TSeries();
+        var eventingInd = new Afirma(pubSource, period, window);
+        for (int i = 0; i < series.Count; i++)
+        {
+            pubSource.Add(series[i]);
+        }
+        double eventingResult = eventingInd.Last.Value;
+
+        // Assert
+        Assert.Equal(expected, spanResult, precision: 9);
+        Assert.Equal(expected, streamingResult, precision: 9);
+        Assert.Equal(expected, eventingResult, precision: 9);
+    }
+
+    [Fact]
+    public void Afirma_Chainability_Works()
+    {
+        var source = new TSeries();
+        var afirma = new Afirma(source, 10);
+
+        source.Add(new TValue(DateTime.UtcNow, 100));
+        Assert.True(double.IsFinite(afirma.Last.Value));
+    }
+
+    [Fact]
+    public void Afirma_WarmupPeriod_IsSetCorrectly()
+    {
+        var afirma = new Afirma(21);
+        Assert.Equal(21, afirma.WarmupPeriod);
+    }
+
+    [Fact]
+    public void Afirma_Prime_SetsStateCorrectly()
+    {
+        var afirma = new Afirma(5);
+        double[] history = [10, 20, 30, 40, 50];
+
+        afirma.Prime(history);
+
+        Assert.True(afirma.IsHot);
+        Assert.True(double.IsFinite(afirma.Last.Value));
+
+        // Verify it continues correctly
+        afirma.Update(new TValue(DateTime.UtcNow, 60));
+        Assert.True(double.IsFinite(afirma.Last.Value));
+    }
+
+    [Fact]
+    public void Afirma_Prime_WithInsufficientHistory_IsNotHot()
+    {
+        var afirma = new Afirma(10);
+        double[] history = [10, 20, 30, 40, 50];
+
+        afirma.Prime(history);
+
+        Assert.False(afirma.IsHot);
+        Assert.True(double.IsFinite(afirma.Last.Value));
+    }
+
+    [Fact]
+    public void Afirma_Prime_HandlesNaN_InHistory()
+    {
+        var afirma = new Afirma(3);
+        double[] history = [10, 20, double.NaN, 40];
+
+        afirma.Prime(history);
+
+        Assert.True(afirma.IsHot);
+        Assert.True(double.IsFinite(afirma.Last.Value));
+    }
+
+    [Fact]
+    public void Afirma_Calculate_ReturnsCorrectResultsAndHotIndicator()
+    {
+        var series = new TSeries();
+        for (int i = 1; i <= 10; i++) series.Add(DateTime.UtcNow, i * 10);
+
+        var (results, indicator) = Afirma.Calculate(series, 5);
+
+        // Check results
+        Assert.Equal(10, results.Count);
+        Assert.True(double.IsFinite(results.Last.Value));
+
+        // Check indicator state
+        Assert.True(indicator.IsHot);
+        Assert.Equal(results.Last.Value, indicator.Last.Value);
+        Assert.Equal(5, indicator.WarmupPeriod);
+
+        // Verify indicator continues correctly
+        indicator.Update(new TValue(DateTime.UtcNow, 110));
+        Assert.True(double.IsFinite(indicator.Last.Value));
+    }
+
+    [Fact]
+    public void Afirma_DifferentWindowTypes_Work()
+    {
+        var windows = new[]
+        {
+            Afirma.WindowType.Rectangular,
+            Afirma.WindowType.Hanning,
+            Afirma.WindowType.Hamming,
+            Afirma.WindowType.Blackman,
+            Afirma.WindowType.BlackmanHarris
+        };
+
+        foreach (var window in windows)
+        {
+            var afirma = new Afirma(10, window);
+
+            for (int i = 0; i < 20; i++)
+            {
+                afirma.Update(new TValue(DateTime.UtcNow, 100 + i));
+            }
+
+            Assert.True(double.IsFinite(afirma.Last.Value), $"Window {window} should produce finite value");
+            Assert.True(afirma.IsHot, $"Window {window} should become hot");
+        }
+    }
+
+    [Fact]
+    public void Afirma_FlatLine_ReturnsSameValue()
+    {
+        var afirma = new Afirma(10);
+
+        for (int i = 0; i < 20; i++)
+        {
+            afirma.Update(new TValue(DateTime.UtcNow, 100));
+        }
+
+        // With a flat line, the filtered value should be close to the input
+        Assert.Equal(100, afirma.Last.Value, 1e-6);
+    }
+
+    [Fact]
+    public void Afirma_Taps1_Works()
+    {
+        var afirma = new Afirma(1);
+
+        var r1 = afirma.Update(new TValue(DateTime.UtcNow, 100));
+        var r2 = afirma.Update(new TValue(DateTime.UtcNow, 200));
+
+        // With 1 tap, output should equal input
+        Assert.Equal(100, r1.Value, 1e-10);
+        Assert.Equal(200, r2.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Afirma_Pub_EventFires()
+    {
+        var afirma = new Afirma(10);
+        bool eventFired = false;
+        afirma.Pub += (object? sender, in TValueEventArgs args) => eventFired = true;
+
+        afirma.Update(new TValue(DateTime.UtcNow, 100));
+        Assert.True(eventFired);
+    }
+}

lib/forecasts/afirma/Afirma.Validation.Tests.cs

@@ -0,0 +1,313 @@
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+/// <summary>
+/// Validation tests for AFIRMA indicator.
+/// AFIRMA is a specialized FIR filter with windowed sinc coefficients.
+/// Since no external library implements this exact algorithm, validation
+/// focuses on internal consistency and mathematical properties.
+/// </summary>
+public sealed class AfirmaValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public AfirmaValidationTests(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_InternalConsistency_Batch()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+
+        foreach (var period in periods)
+        {
+            // Calculate QuanTAlib AFIRMA (batch TSeries)
+            var afirma = new Afirma(period);
+            var qResult = afirma.Update(_testData.Data);
+
+            // Verify all results are finite
+            foreach (var val in qResult)
+            {
+                Assert.True(double.IsFinite(val.Value),
+                    $"AFIRMA({period}) produced non-finite value");
+            }
+
+            // Verify count matches input
+            Assert.Equal(_testData.Data.Count, qResult.Count);
+        }
+        _output.WriteLine("AFIRMA Batch(TSeries) internal consistency validated");
+    }
+
+    [Fact]
+    public void Validate_InternalConsistency_Streaming()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+
+        foreach (var period in periods)
+        {
+            // Calculate QuanTAlib AFIRMA (streaming)
+            var afirma = new Afirma(period);
+            var qResults = new List<double>();
+            foreach (var item in _testData.Data)
+            {
+                qResults.Add(afirma.Update(item).Value);
+            }
+
+            // Verify all results are finite
+            foreach (var val in qResults)
+            {
+                Assert.True(double.IsFinite(val),
+                    $"AFIRMA({period}) streaming produced non-finite value");
+            }
+
+            // Verify count matches input
+            Assert.Equal(_testData.Data.Count, qResults.Count);
+        }
+        _output.WriteLine("AFIRMA Streaming internal consistency validated");
+    }
+
+    [Fact]
+    public void Validate_InternalConsistency_Span()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+
+        // Prepare data for Span API
+        double[] sourceData = _testData.RawData.ToArray();
+
+        foreach (var period in periods)
+        {
+            // Calculate QuanTAlib AFIRMA (Span API)
+            double[] qOutput = new double[sourceData.Length];
+            Afirma.Batch(sourceData.AsSpan(), qOutput.AsSpan(), period);
+
+            // Verify all results are finite
+            foreach (var val in qOutput)
+            {
+                Assert.True(double.IsFinite(val),
+                    $"AFIRMA({period}) span produced non-finite value");
+            }
+        }
+        _output.WriteLine("AFIRMA Span internal consistency validated");
+    }
+
+    [Fact]
+    public void Validate_BatchStreamingConsistency()
+    {
+        int[] periods = { 5, 10, 20 };
+
+        foreach (var period in periods)
+        {
+            // Batch calculation
+            var afirmaBatch = new Afirma(period);
+            var batchResult = afirmaBatch.Update(_testData.Data);
+
+            // Streaming calculation
+            var afirmaStream = new Afirma(period);
+            var streamResults = new List<double>();
+            foreach (var item in _testData.Data)
+            {
+                streamResults.Add(afirmaStream.Update(item).Value);
+            }
+
+            // Compare last 100 values
+            int compareCount = Math.Min(100, batchResult.Count);
+            for (int i = 0; i < compareCount; i++)
+            {
+                int idx = batchResult.Count - compareCount + i;
+                Assert.Equal(batchResult[idx].Value, streamResults[idx], 1e-10);
+            }
+        }
+        _output.WriteLine("AFIRMA Batch/Streaming consistency validated");
+    }
+
+    [Fact]
+    public void Validate_SpanBatchConsistency()
+    {
+        int[] periods = { 5, 10, 20 };
+
+        double[] sourceData = _testData.RawData.ToArray();
+
+        foreach (var period in periods)
+        {
+            // TSeries Batch
+            var afirma = new Afirma(period);
+            var tseriesResult = afirma.Update(_testData.Data);
+
+            // Span Batch
+            double[] spanOutput = new double[sourceData.Length];
+            Afirma.Batch(sourceData.AsSpan(), spanOutput.AsSpan(), period);
+
+            // Compare
+            for (int i = 0; i < sourceData.Length; i++)
+            {
+                Assert.Equal(tseriesResult[i].Value, spanOutput[i], 1e-10);
+            }
+        }
+        _output.WriteLine("AFIRMA Span/Batch consistency validated");
+    }
+
+    [Fact]
+    public void Validate_WindowTypes_Consistency()
+    {
+        var windows = new[]
+        {
+            Afirma.WindowType.Rectangular,
+            Afirma.WindowType.Hanning,
+            Afirma.WindowType.Hamming,
+            Afirma.WindowType.Blackman,
+            Afirma.WindowType.BlackmanHarris
+        };
+
+        const int period = 10;
+
+        foreach (var window in windows)
+        {
+            // Batch
+            var afirmaBatch = new Afirma(period, window);
+            var batchResult = afirmaBatch.Update(_testData.Data);
+
+            // Streaming
+            var afirmaStream = new Afirma(period, window);
+            foreach (var item in _testData.Data)
+            {
+                afirmaStream.Update(item);
+            }
+
+            // Compare last values
+            Assert.Equal(batchResult.Last.Value, afirmaStream.Last.Value, 1e-10);
+            _output.WriteLine($"Window {window}: Batch={batchResult.Last.Value:F6}, Stream={afirmaStream.Last.Value:F6}");
+        }
+        _output.WriteLine("AFIRMA Window types consistency validated");
+    }
+
+    [Fact]
+    public void Validate_FlatInput_ReturnsConstant()
+    {
+        int period = 10;
+        double constantValue = 100.0;
+
+        // Create flat input
+        var flatSeries = new TSeries();
+        for (int i = 0; i < 100; i++)
+        {
+            flatSeries.Add(DateTime.UtcNow.AddSeconds(i), constantValue);
+        }
+
+        var afirma = new Afirma(period);
+        var result = afirma.Update(flatSeries);
+
+        // After warmup, all values should equal the constant
+        for (int i = period; i < result.Count; i++)
+        {
+            Assert.Equal(constantValue, result[i].Value, 1e-9);
+        }
+        _output.WriteLine($"AFIRMA flat input returns constant: {result.Last.Value:F9}");
+    }
+
+    [Fact]
+    public void Validate_Smoothing_ReducesVariance()
+    {
+        int period = 21;
+
+        // Calculate variance of input
+        var rawData = _testData.RawData.ToArray();
+        double inputMean = rawData.Average();
+        double inputVariance = rawData.Average(x => Math.Pow(x - inputMean, 2));
+
+        // Calculate AFIRMA
+        var afirma = new Afirma(period);
+        var result = afirma.Update(_testData.Data);
+
+        // Calculate variance of output (after warmup)
+        var outputValues = result.Skip(period).Select(v => v.Value).ToList();
+        double outputMean = outputValues.Average();
+        double outputVariance = outputValues.Average(x => Math.Pow(x - outputMean, 2));
+
+        // Output variance should be less than input variance (smoothing effect)
+        Assert.True(outputVariance < inputVariance,
+            $"AFIRMA should reduce variance. Input: {inputVariance:F4}, Output: {outputVariance:F4}");
+
+        _output.WriteLine($"AFIRMA smoothing effect: Input variance={inputVariance:F4}, Output variance={outputVariance:F4}");
+    }
+
+    [Fact]
+    public void Validate_LargerPeriod_MoreSmoothing()
+    {
+        // Calculate with different periods (which implies different tap counts)
+        var afirma5 = new Afirma(5);
+        var afirma11 = new Afirma(11);
+        var afirma21 = new Afirma(21);
+
+        var result5 = afirma5.Update(_testData.Data);
+        var result11 = afirma11.Update(_testData.Data);
+        var result21 = afirma21.Update(_testData.Data);
+
+        // Calculate variance of each
+        double GetVariance(TSeries series, int skip)
+        {
+            var values = series.Skip(skip).Select(v => v.Value).ToList();
+            double mean = values.Average();
+            return values.Average(x => Math.Pow(x - mean, 2));
+        }
+
+        double var5 = GetVariance(result5, 5);
+        double var11 = GetVariance(result11, 11);
+        double var21 = GetVariance(result21, 21);
+
+        // Larger period should generally produce smoother output (lower variance)
+        // This is a statistical property, not guaranteed for all data
+        _output.WriteLine($"Variance by period: 5={var5:F4}, 11={var11:F4}, 21={var21:F4}");
+
+        // At minimum, all should be finite
+        Assert.True(double.IsFinite(var5));
+        Assert.True(double.IsFinite(var11));
+        Assert.True(double.IsFinite(var21));
+    }
+
+    [Fact]
+    public void Validate_DifferentWindows_DifferentCharacteristics()
+    {
+        int period = 10;
+
+        var rectangularResult = Afirma.Batch(_testData.Data, period, Afirma.WindowType.Rectangular);
+        var blackmanHarrisResult = Afirma.Batch(_testData.Data, period, Afirma.WindowType.BlackmanHarris);
+
+        // Results should be different (different window characteristics)
+        double rectLast = rectangularResult.Last.Value;
+        double bhLast = blackmanHarrisResult.Last.Value;
+
+        // They should generally not be exactly equal
+        // (unless input happens to be perfectly constant)
+        _output.WriteLine($"Rectangular: {rectLast:F6}, Blackman-Harris: {bhLast:F6}");
+
+        // Both should be finite and reasonable
+        Assert.True(double.IsFinite(rectLast));
+        Assert.True(double.IsFinite(bhLast));
+    }
+}

lib/forecasts/afirma/Afirma.cs

@@ -0,0 +1,580 @@
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// AFIRMA: Autoregressive FIR Moving Average
+/// A Windowed Weighted Moving Average that uses standard window functions (Hanning, Hamming,
+/// Blackman, Blackman-Harris) as filter coefficients.
+/// Optionally applies Least Squares Cubic Polynomial fitting for autoregressive prediction.
+/// </summary>
+/// <remarks>
+/// AFIRMA calculates a weighted average where weights are determined by a window function.
+/// Unlike standard WMAs that assume linear or triangle weights, AFIRMA uses signal processing
+/// windows to achieve specific frequency response characteristics.
+///
+/// The filter equation:
+///    y[n] = (Σ w_k · x[n-k]) / (Σ w_k)
+///
+/// Window Functions:
+/// - Hanning: 0.5 - 0.5cos(x)
+/// - Hamming: 0.54 - 0.46cos(x)
+/// - Blackman: 0.42 - 0.5cos(x) + 0.08cos(2x)
+/// - Blackman-Harris: 0.35875 - 0.48829cos(x) + 0.14128cos(2x) - 0.01168cos(3x)
+///
+/// Parameters:
+/// - Period: The length of the window.
+/// - Window: The window function to use for weights.
+/// - LeastSquares: Enable cubic polynomial fitting (default: false).
+/// </remarks>
+[SkipLocalsInit]
+public sealed class Afirma : AbstractBase
+{
+    /// <summary>
+    /// Available window functions for the FIR filter.
+    /// </summary>
+    public enum WindowType
+    {
+        /// <summary>No windowing - simple rectangular window (SMA)</summary>
+        Rectangular,
+        /// <summary>Hanning window</summary>
+        Hanning,
+        /// <summary>Hamming window</summary>
+        Hamming,
+        /// <summary>Blackman window (3-term)</summary>
+        Blackman,
+        /// <summary>Blackman-Harris window (4-term, minimum sidelobe)</summary>
+        BlackmanHarris,
+    }
+
+    private readonly int _period;
+    private readonly WindowType _window;
+    private readonly bool _leastSquares;
+    private readonly RingBuffer _buffer;
+    private readonly double[] _weights;
+    private readonly double _invWeightSum;
+    private readonly TValuePublishedHandler _handler;
+    private ITValuePublisher? _publisher;
+    private bool _isNew;
+
+    [StructLayout(LayoutKind.Auto)]
+    private record struct State(double LastValidValue)
+    {
+        public static State New() => new() { LastValidValue = double.NaN };
+    }
+
+    private State _state = State.New();
+    private State _p_state = State.New();
+
+    /// <summary>
+    /// Creates AFIRMA with specified parameters.
+    /// </summary>
+    /// <param name="period">The window size (filter length), must be >= 1.</param>
+    /// <param name="window">Window function to apply.</param>
+    /// <param name="leastSquares">Enable least squares fitting.</param>
+    public Afirma(int period, WindowType window = WindowType.BlackmanHarris, bool leastSquares = false)
+    {
+        if (period < 1)
+            throw new ArgumentException("Period must be at least 1", nameof(period));
+
+        _period = period;
+        _window = window;
+        _leastSquares = leastSquares;
+        _buffer = new RingBuffer(period);
+        _weights = new double[period];
+        _invWeightSum = 1.0 / CalculateWeights();
+
+        Name = $"Afirma({period},{window},{leastSquares})";
+        WarmupPeriod = period;
+        _handler = Handle;
+    }
+
+    /// <summary>
+    /// Creates AFIRMA with a data source subscription.
+    /// </summary>
+    public Afirma(ITValuePublisher source, int period, WindowType window = WindowType.BlackmanHarris, bool leastSquares = false)
+        : this(period, window, leastSquares)
+    {
+        _publisher = source;
+        source.Pub += _handler;
+    }
+
+    /// <summary>
+    /// Creates AFIRMA with TSeries source for priming.
+    /// </summary>
+    public Afirma(TSeries source, int period, WindowType window = WindowType.BlackmanHarris, bool leastSquares = false)
+        : this(period, window, leastSquares)
+    {
+        _publisher = source;
+        Prime(source.Values);
+        if (source.Count > 0)
+        {
+            Last = new TValue(source.LastTime, Last.Value);
+        }
+        source.Pub += _handler;
+    }
+
+    private void Handle(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
+
+    /// <summary>
+    /// Gets a value indicating whether the most recent update was a new data point.
+    /// </summary>
+    public bool IsNew => _isNew;
+
+    /// <summary>
+    /// True if the AFIRMA has enough data to produce valid results.
+    /// </summary>
+    public override bool IsHot => _buffer.IsFull;
+
+    /// <summary>
+    /// Initializes the indicator state using the provided history.
+    /// </summary>
+    public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
+    {
+        if (source.Length == 0) return;
+
+        // Reset state
+        _buffer.Clear();
+        _state = State.New();
+        _p_state = State.New();
+
+        int warmupLength = Math.Min(source.Length, WarmupPeriod);
+        int startIndex = source.Length - warmupLength;
+
+        // Find first valid value for NaN handling
+        _state.LastValidValue = double.NaN;
+        for (int i = startIndex - 1; i >= 0; i--)
+        {
+            if (double.IsFinite(source[i]))
+            {
+                _state.LastValidValue = source[i];
+                break;
+            }
+        }
+
+        if (double.IsNaN(_state.LastValidValue))
+        {
+            for (int i = startIndex; i < source.Length; i++)
+            {
+                if (double.IsFinite(source[i]))
+                {
+                    _state.LastValidValue = source[i];
+                    break;
+                }
+            }
+        }
+
+        // Feed the RingBuffer
+        for (int i = startIndex; i < source.Length; i++)
+        {
+            double val = GetValidValue(source[i]);
+            _buffer.Add(val);
+        }
+
+        // Calculate initial value
+        double result = CalculateAfirma();
+        Last = new TValue(DateTime.MinValue, result);
+        _p_state = _state;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double GetValidValue(double input, bool updateState = true)
+    {
+        if (double.IsFinite(input))
+        {
+            if (updateState)
+                _state.LastValidValue = input;
+            return input;
+        }
+        return _state.LastValidValue;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override TValue Update(TValue input, bool isNew = true)
+    {
+        _isNew = isNew;
+        if (isNew)
+        {
+            _p_state = _state;
+        }
+        else
+        {
+            _state = _p_state;
+        }
+
+        double val = GetValidValue(input.Value, updateState: false);
+        if (double.IsFinite(input.Value))
+        {
+            _state.LastValidValue = input.Value;
+        }
+
+        _buffer.Add(val, isNew);
+
+        double result = CalculateAfirma();
+        Last = new TValue(input.Time, result);
+        PubEvent(Last, isNew);
+        return Last;
+    }
+
+    public override TSeries Update(TSeries source)
+    {
+        if (source.Count == 0) return [];
+
+        int len = source.Count;
+        var t = new List<long>(len);
+        var v = new List<double>(len);
+        CollectionsMarshal.SetCount(t, len);
+        CollectionsMarshal.SetCount(v, len);
+
+        var tSpan = CollectionsMarshal.AsSpan(t);
+        var vSpan = CollectionsMarshal.AsSpan(v);
+
+        Batch(source.Values, vSpan, _period, _window, _leastSquares);
+        source.Times.CopyTo(tSpan);
+
+        Prime(source.Values);
+
+        Last = new TValue(tSpan[len - 1], vSpan[len - 1]);
+        return new TSeries(t, v);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double CalculateAfirma()
+    {
+        int count = _buffer.Count;
+        if (count == 0) return double.NaN;
+
+        double result;
+
+        // Warmup path or steady state for Base AFIRMA
+        if (count < _period)
+        {
+            result = 0.0;
+            double effectiveWeightSum = 0.0;
+            for (int k = 0; k < count; k++)
+            {
+                double w = _weights[k];
+                result = Math.FusedMultiplyAdd(_buffer[k], w, result);
+                effectiveWeightSum += w;
+            }
+            result = effectiveWeightSum > 0 ? result / effectiveWeightSum : _buffer.Newest;
+        }
+        else
+        {
+            // Steady state
+            double sum = 0.0;
+            for (int k = 0; k < _period; k++)
+            {
+                sum = Math.FusedMultiplyAdd(_buffer[k], _weights[k], sum);
+            }
+            result = sum * _invWeightSum;
+        }
+
+        // Least Squares path - overwrites result if enabled and sufficient data
+        if (_leastSquares && count > 2)
+        {
+            int n = Math.Min((count - 1) / 2, 50); // Pine: math.min(math.floor((p - 1) / 2), 50)
+            if (n >= 2)
+            {
+                // Linear Regression on most recent n points (0 to n-1 in Pine lag terms)
+                // Pine lag 0 = Newest. Pine lag n-1 = Newest - (n-1).
+                // x coordinates: 0, 1, ..., n-1 (lags)
+                // y coordinates: buffer values corresponding to lags.
+                // we want fitted line: y = intercept + slope * x
+
+                double sx = 0.0, sx2 = 0.0, sy = 0.0, sxy = 0.0;
+                // Precalculate sx, sx2 (depends only on n)
+                // sx = sum(i) for i=0..n-1 = (n-1)*n/2
+                // sx2 = sum(i^2) for i=0..n-1 = (n-1)*n*(2n-2+1)/6 = (n-1)*n*(2n-1)/6
+                // Calculation in loop for clarity or formula:
+                double dn = (double)n;
+                sx = (dn - 1.0) * dn * 0.5;
+                sx2 = (dn - 1.0) * dn * (2.0 * dn - 1.0) / 6.0;
+
+                for (int i = 0; i < n; i++)
+                {
+                    // Pine uses src[i] where i is lag. i=0 is newest.
+                    // RingBuffer: Newest is at index count-1.
+                    // Value at lag i: _buffer[count - 1 - i]
+                    double val = _buffer[count - 1 - i];
+                    sy += val;
+                    sxy += i * val;
+                }
+
+                double denom = dn * sx2 - sx * sx;
+                if (Math.Abs(denom) > 1e-10)
+                {
+                    double slope = (dn * sxy - sx * sy) / denom;
+                    double intercept = (sy - slope * sx) / dn;
+
+                    double lsSum = 0.0;
+                    double lsCount = 0.0;
+
+                    // Pine loop: for i = 0 to p - 1
+                    // if i < n ? fitted : src[i]
+                    // We loop over the full period (or count).
+                    // We average the "hybrid" window.
+
+                    for (int i = 0; i < count; i++)
+                    {
+                        double val;
+                        if (i < n)
+                        {
+                            // Use fitted value: intercept + slope * i
+                            val = intercept + slope * i;
+                        }
+                        else
+                        {
+                            // Use original value from buffer
+                            // At lag i
+                            val = _buffer[count - 1 - i];
+                        }
+                        lsSum += val;
+                        lsCount++;
+                    }
+                    if (lsCount > 0)
+                    {
+                        result = lsSum / lsCount;
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double CalculateWeights()
+    {
+        double wsum = 0.0;
+
+        // Coefficients based on Pine Script implementation
+        double a0 = 0.35875, a1 = -0.48829, a2 = 0.14128, a3 = -0.01168;
+
+        if (_window == WindowType.Hanning)
+        {
+            a0 = 0.50; a1 = -0.50; a2 = 0.0; a3 = 0.0;
+        }
+        else if (_window == WindowType.Hamming)
+        {
+            a0 = 0.54; a1 = -0.46; a2 = 0.0; a3 = 0.0;
+        }
+        else if (_window == WindowType.Blackman)
+        {
+            a0 = 0.42; a1 = -0.50; a2 = 0.08; a3 = 0.0;
+        }
+        else if (_window == WindowType.Rectangular)
+        {
+            a0 = 1.0; a1 = 0.0; a2 = 0.0; a3 = 0.0;
+        }
+
+        double twoPiDivP = 2.0 * Math.PI / _period;
+
+        for (int k = 0; k < _period; k++)
+        {
+            double kTwoPiDivP = k * twoPiDivP;
+            double coef = a0 + a1 * Math.Cos(kTwoPiDivP);
+            if (Math.Abs(a2) > 1e-9)
+                coef += a2 * Math.Cos(2.0 * kTwoPiDivP);
+            if (Math.Abs(a3) > 1e-9)
+                coef += a3 * Math.Cos(3.0 * kTwoPiDivP);
+
+            _weights[k] = coef;
+            wsum += coef;
+        }
+        return wsum;
+    }
+
+    /// <summary>
+    /// Calculates AFIRMA for the entire series using a new instance.
+    /// </summary>
+    public static TSeries Batch(TSeries source, int period, WindowType window = WindowType.BlackmanHarris, bool leastSquares = false)
+    {
+        var afirma = new Afirma(period, window, leastSquares);
+        return afirma.Update(source);
+    }
+
+    /// <summary>
+    /// Calculates AFIRMA in-place, writing results to pre-allocated output span.
+    /// Optimized with stackalloc and FMA.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Batch(ReadOnlySpan<double> source, Span<double> output, int period, WindowType window = WindowType.BlackmanHarris, bool leastSquares = false)
+    {
+        if (source.Length != output.Length)
+            throw new ArgumentException("Source and output must have the same length", nameof(output));
+        if (period < 1)
+            throw new ArgumentException("Period must be at least 1", nameof(period));
+
+        int len = source.Length;
+        if (len == 0) return;
+
+        // If leastSquares is enabled, use standard Update loop via object or specialized loop.
+        // Implementing LS efficiently in Batch/Span is complex because of regression in inner loop.
+        // For parity and code reuse without duplication, simpler to instantiate object for LS path or duplicate logic.
+        // BUT Batch(Span) should remain allocation free if possible.
+        // LS logic fits a line for every bar. That's O(Period) per bar. Simpler WMA is also O(Period) or O(1) if optimized sliding but here it's convolution.
+        // Given complexity of LS, strict 0-alloc might require large stack buffers for sx/sy/etc or careful math.
+        // Let's implement the core logic inside the loop.
+
+        const int StackAllocThreshold = 256;
+
+        // Allocate weights - use ArrayPool for large buffers to avoid heap allocation
+        double[]? rentedWeights = period > StackAllocThreshold ? ArrayPool<double>.Shared.Rent(period) : null;
+        Span<double> weights = rentedWeights != null
+            ? rentedWeights.AsSpan(0, period)
+            : stackalloc double[period];
+
+        // Allocate circular buffer - use ArrayPool for large buffers
+        double[]? rentedBuffer = period > StackAllocThreshold ? ArrayPool<double>.Shared.Rent(period) : null;
+        Span<double> buffer = rentedBuffer != null
+            ? rentedBuffer.AsSpan(0, period)
+            : stackalloc double[period];
+
+        try
+        {
+        // Pre-calculate weights (Static version of CalculateWeights)
+        // ... (Copy of weights calc logic)
+        double a0 = 0.35875, a1 = -0.48829, a2 = 0.14128, a3 = -0.01168;
+        if (window == WindowType.Hanning) { a0 = 0.50; a1 = -0.50; a2 = 0.0; a3 = 0.0; }
+        else if (window == WindowType.Hamming) { a0 = 0.54; a1 = -0.46; a2 = 0.0; a3 = 0.0; }
+        else if (window == WindowType.Blackman) { a0 = 0.42; a1 = -0.50; a2 = 0.08; a3 = 0.0; }
+        else if (window == WindowType.Rectangular) { a0 = 1.0; a1 = 0.0; a2 = 0.0; a3 = 0.0; }
+
+        double twoPiDivP = 2.0 * Math.PI / period;
+        for (int k = 0; k < period; k++)
+        {
+            double kTwoPiDivP = k * twoPiDivP;
+            double coef = a0 + a1 * Math.Cos(kTwoPiDivP);
+            if (Math.Abs(a2) > 1e-9) coef += a2 * Math.Cos(2.0 * kTwoPiDivP);
+            if (Math.Abs(a3) > 1e-9) coef += a3 * Math.Cos(3.0 * kTwoPiDivP);
+            weights[k] = coef;
+        }
+
+        double lastValid = double.NaN;
+        for (int k = 0; k < len; k++)
+            if (double.IsFinite(source[k])) { lastValid = source[k]; break; }
+
+        int bufferIndex = 0;
+        int bufferCount = 0;
+
+        for (int i = 0; i < len; i++)
+        {
+            double val = source[i];
+            if (double.IsFinite(val)) lastValid = val; else val = lastValid;
+
+            buffer[bufferIndex] = val;
+            bufferIndex = (bufferIndex + 1) % period;
+            if (bufferCount < period) bufferCount++;
+
+            // Base AFIRMA (WMA)
+            double result = 0.0;
+            double effectiveWeightSum = 0.0;
+            int readIndex = (bufferIndex - bufferCount + period) % period;
+
+            for (int k = 0; k < bufferCount; k++)
+            {
+                // Match Streaming: weights[k] corresponds to Oldest + k
+                int idx = (readIndex + k) % period;
+                result = Math.FusedMultiplyAdd(buffer[idx], weights[k], result);
+                effectiveWeightSum += weights[k];
+            }
+            output[i] = effectiveWeightSum > 0 ? result / effectiveWeightSum : val;
+
+            // Least Squares Path
+            if (leastSquares && bufferCount > 2)
+            {
+                int n = Math.Min((bufferCount - 1) / 2, 50);
+                if (n >= 2)
+                {
+                    double sx = 0.0, sx2 = 0.0, sy = 0.0, sxy = 0.0;
+                    double dn = (double)n;
+                    sx = (dn - 1.0) * dn * 0.5;
+                    sx2 = (dn - 1.0) * dn * (2.0 * dn - 1.0) / 6.0;
+
+                    for (int j = 0; j < n; j++)
+                    {
+                        // lag j
+                        int idx = (readIndex + bufferCount - 1 - j + period) % period;
+                        double v = buffer[idx];
+                        sy += v;
+                        sxy += j * v;
+                    }
+
+                    double denom = dn * sx2 - sx * sx;
+                    if (Math.Abs(denom) > 1e-10)
+                    {
+                        double slope = (dn * sxy - sx * sy) / denom;
+                        double intercept = (sy - slope * sx) / dn;
+
+                        double lsSum = 0.0;
+                        double lsCount = 0.0;
+
+                        for (int j = 0; j < bufferCount; j++)
+                        {
+                             // lag j
+                            double v_ls;
+                            if (j < n)
+                            {
+                                v_ls = intercept + slope * j;
+                            }
+                            else
+                            {
+                                int idx = (readIndex + bufferCount - 1 - j + period) % period;
+                                v_ls = buffer[idx];
+                            }
+                            lsSum += v_ls;
+                            lsCount++;
+                        }
+                        if (lsCount > 0)
+                        {
+                            output[i] = lsSum / lsCount;
+                        }
+                    }
+                }
+            }
+        }
+        }
+        finally
+        {
+            // Return rented arrays to the pool
+            if (rentedWeights != null)
+                ArrayPool<double>.Shared.Return(rentedWeights);
+            if (rentedBuffer != null)
+                ArrayPool<double>.Shared.Return(rentedBuffer);
+        }
+    }
+
+    /// <summary>
+    /// Runs a batch calculation and returns a hot indicator instance.
+    /// </summary>
+    public static (TSeries Results, Afirma Indicator) Calculate(TSeries source, int period, WindowType window = WindowType.BlackmanHarris, bool leastSquares = false)
+    {
+        var afirma = new Afirma(period, window, leastSquares);
+        TSeries results = afirma.Update(source);
+        return (results, afirma);
+    }
+
+    /// <summary>
+    /// Resets the AFIRMA state.
+    /// </summary>
+    public override void Reset()
+    {
+        _buffer.Clear();
+        _state = State.New();
+        _p_state = State.New();
+        Last = default;
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing && _publisher != null)
+        {
+            _publisher.Pub -= _handler;
+            _publisher = null;
+        }
+        base.Dispose(disposing);
+    }
+}

lib/forecasts/afirma/Afirma.md

@@ -0,0 +1,174 @@
+# AFIRMA: Autoregressive FIR Moving Average
+
+> "Standard Moving Averages assume linear or exponential weights. AFIRMA asks: what if we used signal processing window functions instead?"
+
+AFIRMA is a Windowed Weighted Moving Average that replaces standard linear weighting with weights derived from signal processing window functions (Hanning, Hamming, Blackman, Blackman-Harris). This approach achieves specific frequency response characteristics tailored to noise reduction.
+
+The optional Least Squares mode fits a linear regression to recent bars and blends the fitted values with original data, producing a hybrid smoothed-predicted output.
+
+## Historical Context
+
+Moving averages traditionally use Simple (rectangular window), Weighted (triangular window), or Exponential (recursive) forms. The DSP community solved finite filter design decades ago using window functions to minimize spectral leakage (ringing artifacts at discontinuities).
+
+AFIRMA applies these well-understood coefficients directly to price series. It is effectively an FIR filter where coefficients are determined solely by the chosen window function—no manual coefficient calculation required.
+
+## Architecture & Physics
+
+AFIRMA maintains a sliding window of the last $P$ prices and computes a weighted average using pre-calculated window coefficients.
+
+### Window Functions
+
+Instead of linear weights ($1, 2, 3...$), AFIRMA generates weights using cosine-sum series:
+
+$$
+w_k = a_0 + a_1 \cos\left(\frac{2\pi k}{P}\right) + a_2 \cos\left(\frac{4\pi k}{P}\right) + a_3 \cos\left(\frac{6\pi k}{P}\right)
+$$
+
+where $P$ is the period and $k$ is the index from $0$ to $P-1$.
+
+| Window | Coefficients | Main Lobe | Side Lobe |
+| :--- | :--- | :---: | :---: |
+| **Rectangular** | $a_0=1$ | Narrowest | −13 dB |
+| **Hanning** | $a_0=0.5$, $a_1=-0.5$ | Medium | −32 dB |
+| **Hamming** | $a_0=0.54$, $a_1=-0.46$ | Medium | −43 dB |
+| **Blackman** | $a_0=0.42$, $a_1=-0.5$, $a_2=0.08$ | Wide | −58 dB |
+| **Blackman-Harris** | $a_0=0.35875$, $a_1=-0.48829$, $a_2=0.14128$, $a_3=-0.01168$ | Widest | −92 dB |
+
+The default **Blackman-Harris** provides maximum side-lobe suppression (−92 dB), ideal for financial data with non-Gaussian noise spikes.
+
+### Least Squares Mode
+
+When `leastSquares=true`, AFIRMA performs an additional step after the base weighted average:
+
+1. **Determine regression window**: $n = \min\left(\lfloor(P-1)/2\rfloor, 50\right)$
+2. **Fit linear regression** to the most recent $n$ bars (lags 0 to $n-1$)
+3. **Create hybrid buffer**: Use fitted values for lags $0$ to $n-1$, original values for lags $n$ to $P-1$
+4. **Average the hybrid buffer**: Simple mean of all $P$ values
+
+This produces a smoothed estimate that incorporates short-term trend extrapolation. The fitted portion projects recent momentum while the original portion anchors to historical context.
+
+Note: Despite some references calling this "cubic polynomial fitting," the actual implementation uses **linear regression** (first-degree polynomial: $y = \text{intercept} + \text{slope} \times x$).
+
+## Mathematical Foundation
+
+### Base Filter Equation
+
+$$
+\text{AFIRMA}_t = \frac{\sum_{k=0}^{P-1} w_k \cdot x_{t-k}}{\sum_{k=0}^{P-1} w_k}
+$$
+
+where $x$ is the input series and $w_k$ are the window weights.
+
+### Window Coefficient Formulas
+
+**Hanning:**
+$$
+w_k = 0.5 - 0.5 \cos\left(\frac{2\pi k}{P}\right)
+$$
+
+**Hamming:**
+$$
+w_k = 0.54 - 0.46 \cos\left(\frac{2\pi k}{P}\right)
+$$
+
+**Blackman:**
+$$
+w_k = 0.42 - 0.5 \cos\left(\frac{2\pi k}{P}\right) + 0.08 \cos\left(\frac{4\pi k}{P}\right)
+$$
+
+**Blackman-Harris:**
+$$
+w_k = 0.35875 - 0.48829 \cos\left(\frac{2\pi k}{P}\right) + 0.14128 \cos\left(\frac{4\pi k}{P}\right) - 0.01168 \cos\left(\frac{6\pi k}{P}\right)
+$$
+
+### Least Squares Regression
+
+Given regression window size $n$:
+
+$$
+S_x = \frac{(n-1)n}{2}, \quad S_{x^2} = \frac{(n-1)n(2n-1)}{6}
+$$
+
+$$
+S_y = \sum_{i=0}^{n-1} x_{t-i}, \quad S_{xy} = \sum_{i=0}^{n-1} i \cdot x_{t-i}
+$$
+
+$$
+\text{slope} = \frac{n \cdot S_{xy} - S_x \cdot S_y}{n \cdot S_{x^2} - S_x^2}
+$$
+
+$$
+\text{intercept} = \frac{S_y - \text{slope} \cdot S_x}{n}
+$$
+
+Fitted value at lag $i$: $\hat{x}_i = \text{intercept} + \text{slope} \cdot i$
+
+Final LS output:
+$$
+\text{AFIRMA}_{LS} = \frac{1}{P} \left( \sum_{i=0}^{n-1} \hat{x}_i + \sum_{i=n}^{P-1} x_{t-i} \right)
+$$
+
+## Parameters
+
+| Parameter | Default | Range | Description |
+| :--- | :---: | :--- | :--- |
+| **Period** | — | ≥ 1 | Window length (number of taps) |
+| **Window** | BlackmanHarris | Enum | Window function for weight generation |
+| **LeastSquares** | false | bool | Enable linear regression blending |
+
+## Performance Profile
+
+| Metric | Value | Notes |
+| :--- | :---: | :--- |
+| **Complexity** | O(P) | Convolution per bar |
+| **Allocations** | 0 | Zero-allocation in Update and Batch spans |
+| **Warmup** | P bars | `WarmupPeriod = period` |
+
+### Quality Metrics
+
+| Metric | Score | Notes |
+| :--- | :---: | :--- |
+| **Accuracy** | 9/10 | Excellent noise suppression |
+| **Timeliness** | 6/10 | Inherent FIR lag (~P/2 bars) |
+| **Overshoot** | 2/10 | Minimal; no recursive amplification |
+| **Smoothness** | 10/10 | Exceptional with Blackman-Harris |
+
+## Validation
+
+| Library | Status | Notes |
+| :--- | :---: | :--- |
+| **Pine Script** | ✅ | Matches `afirma.pine` reference |
+| **Internal** | ✅ | Batch, Streaming, Span modes consistent |
+| **TA-Lib** | N/A | Not implemented |
+| **Skender** | N/A | Not implemented |
+
+## Window Comparison
+
+For identical period, different windows trade smoothness for responsiveness:
+
+| Window | Smoothness | Lag | Best For |
+| :--- | :---: | :---: | :--- |
+| Rectangular | Low | Lowest | Equivalent to SMA |
+| Hanning | Medium | Medium | Balanced general use |
+| Hamming | Medium-High | Medium | Better spectral properties than Hanning |
+| Blackman | High | Higher | Noisy trending markets |
+| BlackmanHarris | Highest | Highest | Maximum noise rejection |
+
+## Common Pitfalls
+
+1. **Lag Increases with Smoothness**: Blackman-Harris has the best noise rejection but also the most lag. For fast signals, consider Hanning or even Rectangular (which degrades to SMA).
+
+2. **Least Squares Is Not Magic**: LS mode adds trend extrapolation but can overshoot during reversals. It works best in trending markets, not choppy conditions.
+
+3. **Large Periods Amplify Lag**: FIR filters have inherent delay of approximately $P/2$ bars. Period 50 means ~25 bars of lag regardless of window choice.
+
+4. **isNew Parameter Matters**: When processing live ticks within the same bar, use `Update(value, isNew: false)`. When a new bar opens, use `isNew: true` (default). Incorrect usage corrupts internal state.
+
+5. **NaN Handling**: Non-finite inputs (NaN, ±Infinity) are replaced with the last valid value. Consecutive NaN inputs maintain the last known good value. After `Reset()`, the first valid input establishes the baseline.
+
+6. **Warmup Period**: AFIRMA requires `period` bars before `IsHot` becomes true. During warmup, it uses available data with proportionally adjusted weights.
+
+## References
+
+- Harris, F. J. (1978). "On the use of windows for harmonic analysis with the discrete Fourier transform." *Proceedings of the IEEE*, 66(1), 51-83.
+- Nuttall, A. H. (1981). "Some windows with very good sidelobe behavior." *IEEE Transactions on Acoustics, Speech, and Signal Processing*, 29(1), 84-91.

lib/forecasts/afirma/afirma.pine

@@ -0,0 +1,121 @@
+// The MIT License (MIT)
+// © mihakralj
+//@version=6
+indicator("Autoregressive FIR Moving Average (AFIRMA)", "AFIRMA", overlay=true)
+
+//@function Calculates AFIRMA using various windowing functions with optional least squares cubic spline fitting
+//@doc https://github.com/mihakralj/pinescript/blob/main/indicators/forecasts/afirma.md
+//@param source Series to calculate AFIRMA from
+//@param period Lookback period - window size
+//@param windowType Window function type (1:Hanning, 2:Hamming, 3:Blackman, 4:Blackman-Harris)
+//@param leastSquares Apply least squares cubic polynomial fitting for autoregressive prediction
+//@returns AFIRMA value, calculates from first bar using available data
+//@optimized Uses windowing functions with O(n) complexity; least squares adds O(n) for polynomial fitting
+afirma(series float src, simple int period, simple int windowType=4, simple bool leastSquares=false) =>
+    float result = src
+    if period <= 0
+        runtime.error("Period must be greater than 0")
+    if windowType < 1 or windowType > 4
+        runtime.error("WindowType should be in range [1-4]")
+    int p = math.min(bar_index + 1, period)
+
+    if p > 1
+        var array<float> coefs = array.new_float(1, 0.0)
+        var int prevPeriod = 0
+        var int prevWindowType = -1
+        if p != prevPeriod or windowType != prevWindowType
+            coefs := array.new_float(p, 0.0)
+            float a0 = 0.35875
+            float a1 = -0.48829
+            float a2 = 0.14128
+            float a3 = -0.01168
+            if windowType == 1
+                a0 := 0.50
+                a1 := -0.50
+            else if windowType == 2
+                a0 := 0.54
+                a1 := -0.46
+            else if windowType == 3
+                a0 := 0.42
+                a1 := -0.50
+                a2 := 0.08
+            float TWO_PI = 6.28318530718
+            float twoPiDivP = TWO_PI / p
+            for k = 0 to p - 1
+                float kTwoPiDivP = k * twoPiDivP
+                float coef = a0 + a1 * math.cos(kTwoPiDivP)
+                if a2 != 0.0
+                    coef += a2 * math.cos(2.0 * kTwoPiDivP)
+                if a3 != 0.0
+                    coef += a3 * math.cos(3.0 * kTwoPiDivP)
+                array.set(coefs, k, coef)
+            prevPeriod := p
+            prevWindowType := windowType
+        float sum = 0.0
+        float weightSum = 0.0
+        int validCount = 0
+        for i = 0 to p - 1
+            float price = src[i]
+            if not na(price)
+                float coef = array.get(coefs, i)
+                sum += price * coef
+                weightSum += coef
+                validCount += 1
+        result := validCount > 0 and weightSum > 0 ? sum / weightSum : src
+
+        if leastSquares and p > 2
+            int n = math.min(math.floor((p - 1) / 2), 50)
+            if n >= 2
+                var float sx = 0.0
+                var float sx2 = 0.0
+                var int prevN = 0
+
+                if n != prevN
+                    sx := 0.0
+                    sx2 := 0.0
+                    for i = 0 to n - 1
+                        sx += i
+                        sx2 += i * i
+                    prevN := n
+
+                float sy = 0.0
+                float sxy = 0.0
+                for i = 0 to n - 1
+                    float yi = nz(src[i])
+                    sy += yi
+                    sxy += i * yi
+
+                float denom = n * sx2 - sx * sx
+                if math.abs(denom) > 1e-10
+                    float slope = (n * sxy - sx * sy) / denom
+                    float intercept = (sy - slope * sx) / n
+
+                    var array<float> fittedBuffer = array.new_float(p, na)
+                    for i = 0 to n - 1
+                        float fitted = intercept + slope * i
+                        array.set(fittedBuffer, i, fitted)
+
+                    float lsSum = 0.0
+                    float lsCount = 0.0
+                    for i = 0 to p - 1
+                        float val = i < n ? array.get(fittedBuffer, i) : nz(src[i])
+                        if not na(val)
+                            lsSum += val
+                            lsCount += 1.0
+
+                    result := lsCount > 0 ? lsSum / lsCount : result
+    result
+
+// ---------- Main loop ----------
+
+// Inputs
+i_period = input.int(20, "Period", minval=1)
+i_source = input.source(close, "Source")
+i_windowType = input.int(4, "Window Function", minval=1, maxval=4, tooltip="1:Hanning, 2:Hamming, 3:Blackman, 4:Blackman-Harris")
+i_leastSquares = input.bool(false, "Least Squares Method", tooltip="Enable cubic polynomial fitting for autoregressive prediction")
+
+// Calculation
+afirma_value = afirma(i_source, i_period, i_windowType, i_leastSquares)
+
+// Plot
+plot(afirma_value, "AFIRMA", color=color.yellow, linewidth=2)

lib/forecasts/mlp/mlp.pine

@@ -0,0 +1,461 @@
+// The MIT License (MIT)
+// © mihakralj
+//@version=6
+indicator("Multilayer Perceptron Predictor", "MLP", overlay=true)
+
+var int offset = 5
+var int numInputs = 6
+var array<int> nodesPerLayer = array.from(8, 4, 1)
+var float learning_rate = 0.0025
+var float learning_rate_decay = 0.000015
+var float max_gradient = 5.0
+var float error_k = 0.7
+var int algoType = 4
+var bool tanh = true
+
+type matrices
+    matrix<float> l0 = na
+    matrix<float> l1 = na
+    matrix<float> l2 = na
+    matrix<float> l3 = na
+    matrix<float> l4 = na
+    matrix<float> l5 = na
+    matrix<float> l6 = na
+    matrix<float> l7 = na
+    matrix<float> l8 = na
+    matrix<float> l9 = na
+var matrices w = na
+var matrices b = na
+
+// ---------- Main loop ----------
+
+//@function Compresses an unbounded value to the range [-1, 1] using tanh or scaled sigmoid
+//@param x The input value (can be any real number)
+//@param useTanh Whether to use tanh (true) or scaled sigmoid (false)
+//@returns A compressed value in range [-1, 1]
+compressToRange(float x, bool useTanh = true) =>
+    if x >= 20.0
+        1.0
+    else if x <= -20.0
+        -1.0
+    else
+        if useTanh
+            ex = math.exp(x)
+            emx = math.exp(-x)
+            (ex - emx) / (ex + emx)
+        else
+            sigmoid = 1.0 / (1.0 + math.exp(-x))
+            2.0 * sigmoid - 1.0
+
+//@function Calculates and normalizes input features in one step
+//@param off Offset value
+//@returns Array of normalized feature values
+calculateInputs(int off) =>
+    norm_arr = array.new_float(0)
+    float f0 = ta.hma(close[off],20) / ta.sma(ta.hma(close[off],20), 100) - 1
+    array.push(norm_arr, compressToRange(f0, tanh))
+
+    if numInputs > 1
+        float f1 = ta.rsi(close[off], 14) / 100
+        array.push(norm_arr, compressToRange(f1, tanh))
+
+    if numInputs > 2
+        float f2 = ta.atr(14)[off] / ta.sma(ta.atr(14), 14)[off]
+        array.push(norm_arr, compressToRange(f2, tanh))
+
+    if numInputs > 3
+        float f3 = close[off] / ta.sma(close, 20)[off]
+        array.push(norm_arr, compressToRange(f3, tanh))
+
+    if numInputs > 4
+        float f4 = ta.mom(close[off], 10) / close[off]
+        array.push(norm_arr, compressToRange(f4, tanh))
+
+    if numInputs > 5
+        float f5 = ta.ema(close[off], 5) / ta.ema(close[off], 20) - 1
+        array.push(norm_arr, compressToRange(f5, tanh))
+
+    if numInputs > 6
+        float f6 = ta.bbw(close[off], 20, 2) / 2
+        array.push(norm_arr, compressToRange(f6, tanh))
+    norm_arr
+
+//@function Converts price format to return format
+//@param reference_price The reference price to compare against
+//@param new_price The current price value
+//@param algo_type Algorithm type: 1=absolute change, 2=return ratio, 3=percentage change, 4=log return
+//@returns The price return format
+transform(float reference_price, float new_price, int algo_type) =>
+    if na(new_price) or na(reference_price) or na(algo_type)
+        na
+    else if reference_price <= 0 and (algo_type > 1)
+        na
+    else if algo_type == 1
+        new_price - reference_price
+    else if algo_type == 2
+        new_price / reference_price
+    else if algo_type == 3
+        (new_price - reference_price) / reference_price
+    else if algo_type == 4
+        ratio = new_price / reference_price
+        ratio <= 0 ? na : math.log(ratio)
+    else
+        na
+
+//@function Converts return format back to price format
+//@param reference_price The reference price value
+//@param price_return The return value
+//@param algo_type Algorithm type: 1=absolute change, 2=return ratio, 3=percentage change, 4=log return
+//@returns The absolute price format
+detransform(float reference_price, float price_return, int algo_type) =>
+    if na(reference_price) or na(price_return) or na(algo_type)
+        na
+    else if reference_price <= 0 and (algo_type > 1)
+        na
+    else if algo_type == 1
+        reference_price + price_return
+    else if algo_type == 2
+        limited_return = math.max(0.01, math.min(10.0, price_return))
+        reference_price * limited_return
+    else if algo_type == 3
+        reference_price * (1 + price_return)
+    else if algo_type == 4
+        limited_return = math.max(-5.0, math.min(5.0, price_return))
+        reference_price * math.exp(limited_return)
+    else
+        na
+
+//@function Expands a value from the range [-1, 1] back to its original unbounded range
+//@param y The compressed value in range [-1, 1]
+//@param useTanh Whether y was produced by tanh (true) or scaled sigmoid (false)
+//@returns The original unbounded value
+expandFromRange(float y, bool useTanh = true) =>
+    y_safe = math.max(-0.9999, math.min(0.9999, y))
+
+    if useTanh
+        0.5 * math.log((1.0 + y_safe) / (1.0 - y_safe))
+    else
+        sigmoid_y = (y_safe + 1.0) / 2.0
+        math.log(sigmoid_y / (1.0 - sigmoid_y))
+
+//@function Calculates Huber loss value that is less sensitive to outliers than MSE squared error
+//@param predicted The model's predicted value
+//@param actual The true target value
+//@param delta The threshold where loss function changes from quadratic to linear (default: 0.7)
+//@returns Loss value combining benefits of MSE and MAE
+huberLoss(float predicted, float actual, float delta = 0.7) =>
+    float error = math.abs(predicted - actual)
+    if error <= delta
+        0.5 * error * error
+    else
+        delta * (error - 0.5 * delta)
+
+//@function Calculates gradient of Huber loss for backpropagation
+//@param predicted The model's predicted value
+//@param actual The true target value
+//@param delta The threshold where gradient changes from linear to constant (default: 0.7)
+//@returns Gradient value for updating weights, clipped for stability
+huberLossGradient(float predicted, float actual, float delta = 0.7) =>
+    float error = predicted - actual
+    float absError = math.abs(error)
+    if absError <= delta
+        error
+    else
+        delta * math.sign(error)
+
+//@function Initializes neural network layer weights using Xavier/Glorot initialization
+//@param inputSize Number of neurons in the input layer
+//@param outputSize Number of neurons in the output layer
+//@param seed Random seed
+//@returns Array containing [weight_matrix, bias_matrix] with weights scaled to maintain variance
+xavierInitLayer(int inputSize, int outputSize, int seed) =>
+    w_matrix = matrix.new<float>(inputSize, outputSize)
+    b_matrix = matrix.new<float>(1, outputSize)
+    limit = math.sqrt(1.0 / (inputSize + outputSize))
+    for idx = 0 to (inputSize * outputSize) - 1
+        r = int(idx / outputSize)
+        c = idx % outputSize
+        scale = c == outputSize - 1 ? 0.1 : 1.0
+        value = scale * limit * math.sin((r + 1) * 13.37 + (c + 1) * 42.42 + seed)
+        matrix.set(w_matrix, r, c, value)
+    for c = 0 to outputSize - 1
+        bias_value = c == outputSize - 1 ? 0.01 : (limit * math.sin((c + 1) * 42.42 + seed))
+        matrix.set(b_matrix, 0, c, bias_value)
+    [w_matrix, b_matrix]
+
+//@function Initializes neural network weights and biases using Xavier initialization
+//@param nodeLayerArray Array containing the number of nodes in each layer
+//@param numInputsInt Number of input features
+//@param seed Random seed
+//@returns A matrices object containing all network weights and biases
+initializeNetwork(array<int> nodeLayerArray, int numInputsInt, seed) =>
+    new_w = matrices.new()
+    new_b = matrices.new()
+    numLayers = array.size(nodeLayerArray)
+    for i = 0 to numLayers - 1
+        inputSize = i == 0 ? numInputsInt : array.get(nodeLayerArray, i - 1)
+        outputSize = array.get(nodeLayerArray, i)
+        [ww, bb] = xavierInitLayer(inputSize, outputSize, seed)
+        if i == 0
+            new_w.l0 := ww
+            new_b.l0 := bb
+        else if i == 1
+            new_w.l1 := ww
+            new_b.l1 := bb
+        else if i == 2
+            new_w.l2 := ww
+            new_b.l2 := bb
+        else if i == 3
+            new_w.l3 := ww
+            new_b.l3 := bb
+        else if i == 4
+            new_w.l4 := ww
+            new_b.l4 := bb
+        else if i == 5
+            new_w.l5 := ww
+            new_b.l5 := bb
+        else if i == 6
+            new_w.l6 := ww
+            new_b.l6 := bb
+        else if i == 7
+            new_w.l7 := ww
+            new_b.l7 := bb
+        else if i == 8
+            new_w.l8 := ww
+            new_b.l8 := bb
+    [new_w, new_b]
+
+//@function Creates a new matrix with activation applied to all elements
+//@param this The input matrix with raw values
+//@param useTanh Whether to use tanh activation
+//@returns A new matrix with activated values
+method activate(matrix<float> this, bool useTanh = false) =>
+    result = matrix.new<float>(matrix.rows(this), matrix.columns(this))
+    for q = 0 to matrix.rows(this) - 1
+        for r = 0 to matrix.columns(this) - 1
+            x = matrix.get(this, q, r)
+            tanh_val = compressToRange(x, useTanh)
+            matrix.set(result, q, r, tanh_val)
+    result
+
+getLayerMatrix(matrices matrices_obj, int layer) =>
+    if layer == 0
+        matrices_obj.l0
+    else if layer == 1
+        matrices_obj.l1
+    else if layer == 2
+        matrices_obj.l2
+    else if layer == 3
+        matrices_obj.l3
+    else if layer == 4
+        matrices_obj.l4
+    else if layer == 5
+        matrices_obj.l5
+    else if layer == 6
+        matrices_obj.l6
+    else if layer == 7
+        matrices_obj.l7
+    else if layer == 8
+        matrices_obj.l8
+    else
+        matrices_obj.l9
+
+setLayerMatrix(matrices matrices_obj, int layer, matrix<float> mat) =>
+    if layer == 0
+        matrices_obj.l0 := mat
+    else if layer == 1
+        matrices_obj.l1 := mat
+    else if layer == 2
+        matrices_obj.l2 := mat
+    else if layer == 3
+        matrices_obj.l3 := mat
+    else if layer == 4
+        matrices_obj.l4 := mat
+    else if layer == 5
+        matrices_obj.l5 := mat
+    else if layer == 6
+        matrices_obj.l6 := mat
+    else if layer == 7
+        matrices_obj.l7 := mat
+    else if layer == 8
+        matrices_obj.l8 := mat
+    matrices_obj
+
+calculateDeltas(matrix<float> weights, matrix<float> activations, matrix<float> next_layer_deltas) =>
+    rows = matrix.rows(weights)
+    cols = matrix.columns(weights)
+    deltas = matrix.new<float>(1, rows, 0.0)
+    for i = 0 to rows - 1
+        error_sum = 0.0
+        for j = 0 to matrix.rows(next_layer_deltas) - 1
+            for k = 0 to matrix.columns(next_layer_deltas) - 1
+                error_sum := error_sum + matrix.get(weights, i, j) * matrix.get(next_layer_deltas, j, k)
+        a_val = matrix.get(activations, 0, i)
+        delta_val = error_sum * (1.0 - a_val * a_val)
+        matrix.set(deltas, 0, i, delta_val)
+    deltas
+
+updateLayerWeights(matrix<float> weights, matrix<float> activations, matrix<float> deltas, float learning_rate, float max_gradient) =>
+    new_weights = matrix.copy(weights)
+    rows = matrix.rows(weights)
+    cols = matrix.columns(weights)
+    delta_cols = matrix.columns(deltas)
+
+    for i = 0 to rows - 1
+        for j = 0 to cols - 1
+            a_val = matrix.get(activations, 0, i)
+            d_val = j < delta_cols ? matrix.get(deltas, 0, j) : 0.0
+            grad = a_val * d_val
+            grad := math.max(-max_gradient, math.min(grad, max_gradient))
+            old_w = matrix.get(weights, i, j)
+            matrix.set(new_weights, i, j, old_w - learning_rate * grad)
+    new_weights
+
+updateLayerBiases(matrix<float> biases, matrix<float> deltas, float learning_rate, float max_gradient) =>
+    new_biases = matrix.copy(biases)
+    cols = matrix.columns(biases)
+    delta_cols = matrix.columns(deltas)
+
+    for j = 0 to cols - 1
+        d_val = j < delta_cols ? matrix.get(deltas, 0, j) : 0.0
+        grad = d_val
+        grad := math.max(-max_gradient, math.min(grad, max_gradient))
+        old_b = matrix.get(biases, 0, j)
+        matrix.set(new_biases, 0, j, old_b - learning_rate * grad)
+    new_biases
+
+//@function Performs forward pass through the neural network
+//@param input_arr Array of input features
+//@returns Array containing [prediction, z_values, a_values]
+forwardPass(array<float> input_arr) =>
+    z_values = matrices.new()
+    a_values = matrices.new()
+    input_matrix = matrix.new<float>(1, numInputs)
+
+    for i = 0 to numInputs - 1
+        feature_value = array.get(input_arr, i)
+        if not na(feature_value)
+            matrix.set(input_matrix, 0, i, feature_value)
+
+    setLayerMatrix(a_values, 0, input_matrix)
+    current_a = input_matrix
+    numLayers = array.size(nodesPerLayer)
+    for i = 0 to numLayers - 1
+        current_w = getLayerMatrix(w, i)
+        current_b = getLayerMatrix(b, i)
+        z = matrix.mult(current_a, current_w)
+        for c = 0 to matrix.columns(z) - 1
+            matrix.set(z, 0, c, matrix.get(z, 0, c) + matrix.get(current_b, 0, c))
+        setLayerMatrix(z_values, i, z)
+        current_a := activate(z)
+        setLayerMatrix(a_values, i + 1, current_a)
+    output_value = matrix.columns(current_a) > 0 ? matrix.get(current_a, 0, 0) : 0.0
+
+    [output_value, z_values, a_values]
+
+//@function Performs backpropagation to update network weights and biases
+//@param prediction The predicted output value from forward pass
+//@param target The target value for training
+//@param z_values Matrices object containing pre-activation values
+//@param a_values Matrices object containing activation values
+//@returns Array of updated weight and bias matrices
+backpropagate(float prediction, float target, matrices z_values, matrices a_values) =>
+    if na(w) or na(b)
+        [w, b]
+    else
+        new_w = matrices.new()
+        new_b = matrices.new()
+
+        numLayers = array.size(nodesPerLayer)
+        for i = 0 to numLayers - 1
+            curr_w = getLayerMatrix(w, i)
+            curr_b = getLayerMatrix(b, i)
+
+            if not na(curr_w) and not na(curr_b)
+                setLayerMatrix(new_w, i, matrix.copy(curr_w))
+                setLayerMatrix(new_b, i, matrix.copy(curr_b))
+
+        var float smooth_error_deriv = 0.0
+        current_learning_rate = learning_rate / (1.0 + learning_rate_decay * bar_index)
+
+        error_derivative = huberLossGradient(prediction, target, 0.7)
+        smooth_error_deriv := error_k * error_derivative + (1.0 - error_k) * smooth_error_deriv
+
+        delta_values = matrices.new()
+
+        output_delta = matrix.new<float>(1, 1, smooth_error_deriv)
+        setLayerMatrix(delta_values, numLayers - 1, output_delta)
+
+        if numLayers > 1
+            for i = numLayers - 2 to 0
+                curr_w = getLayerMatrix(w, i + 1)
+                curr_a = getLayerMatrix(a_values, i + 1)
+                next_delta = getLayerMatrix(delta_values, i + 1)
+
+                curr_delta = calculateDeltas(curr_w, curr_a, next_delta)
+                setLayerMatrix(delta_values, i, curr_delta)
+
+        if numLayers == 1
+            input_delta = matrix.new<float>(1, numInputs, 0.0)
+            setLayerMatrix(delta_values, 0, input_delta)
+
+        for i = 0 to numLayers - 1
+            curr_w = getLayerMatrix(w, i)
+            curr_b = getLayerMatrix(b, i)
+            curr_delta = getLayerMatrix(delta_values, i)
+            curr_a = getLayerMatrix(a_values, i)
+
+            new_curr_w = updateLayerWeights(curr_w, curr_a, curr_delta, current_learning_rate, max_gradient)
+            new_curr_b = updateLayerBiases(curr_b, curr_delta, current_learning_rate, max_gradient)
+
+            setLayerMatrix(new_w, i, new_curr_w)
+            setLayerMatrix(new_b, i, new_curr_b)
+        [new_w, new_b]
+
+var matrices z_matrices = na
+var matrices a_matrices = na
+var float normalized_actual_return = na
+var float normalized_predicted_return = na
+var float predicted_price = na
+var float future_price = na
+
+if bar_index > offset
+    normalized_inputs = calculateInputs(offset)
+
+    if barstate.isfirst or (bar_index == offset + 1)
+        [new_w, new_b] = initializeNetwork(nodesPerLayer, numInputs, 42)
+        w := new_w
+        b := new_b
+        [temp_pred, temp_z, temp_a] = forwardPass(normalized_inputs)
+        normalized_predicted_return := temp_pred
+        z_matrices := temp_z
+        a_matrices := temp_a
+
+        actual_return = transform(close[offset], close, algoType)
+        normalized_actual_return := compressToRange(actual_return)
+
+    if not barstate.isrealtime
+        if not na(normalized_predicted_return) and not na(normalized_actual_return)
+            [new_ww, new_bb] = backpropagate(normalized_predicted_return, normalized_actual_return, z_matrices, a_matrices)
+            w := new_ww
+            b := new_bb
+
+    [temp_pred, temp_z, temp_a] = forwardPass(normalized_inputs)
+    normalized_predicted_return := temp_pred
+    z_matrices := temp_z
+    a_matrices := temp_a
+
+    normalized_predicted_price = expandFromRange(normalized_predicted_return)
+    predicted_price := detransform(close[offset], normalized_predicted_price, algoType)
+
+    if barstate.isrealtime
+        future_inputs = calculateInputs(0)
+        [future_pred, _, _] = forwardPass(future_inputs)
+        future_denorm = expandFromRange(future_pred)
+        future_price := detransform(close, future_denorm, algoType)
+        if not na(future_price)
+            label.new(bar_index, high,
+                      "Predicted in " + str.tostring(offset) + " bars: " + str.tostring(future_price, "#.##"),
+                      color=color.green, style=label.style_label_down)
+
+plot(predicted_price, "Historical Prediction", color=color.yellow, linewidth=2, offset = -offset)