adding missing validations

lib/numerics/cwt/Cwt.Quantower.Tests.cs

@@ -0,0 +1,184 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class CwtIndicatorTests
+{
+    [Fact]
+    public void CwtIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new CwtIndicator();
+
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.Equal(10.0, indicator.Scale);
+        Assert.Equal(6.0, indicator.Omega0);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("CWT - Continuous Wavelet Transform", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void CwtIndicator_MinHistoryDepths_CorrectForScale10()
+    {
+        // scale=10: halfWindow=round(30)=30, windowSize=61
+        var indicator = new CwtIndicator { Scale = 10.0 };
+        Assert.Equal(61, indicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void CwtIndicator_MinHistoryDepths_CorrectForScale5()
+    {
+        // scale=5: halfWindow=round(15)=15, windowSize=31
+        var indicator = new CwtIndicator { Scale = 5.0 };
+        Assert.Equal(31, indicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void CwtIndicator_ShortName_IsCorrect()
+    {
+        var indicator = new CwtIndicator { Scale = 20.0, Omega0 = 5.0 };
+        Assert.Equal("CWT(20,5)", indicator.ShortName);
+    }
+
+    [Fact]
+    public void CwtIndicator_Initialize_CreatesTwoLineSeries()
+    {
+        var indicator = new CwtIndicator();
+        indicator.Initialize();
+
+        Assert.Equal(2, indicator.LinesSeries.Count);
+        Assert.Equal("CWT Magnitude", indicator.LinesSeries[0].Name);
+        Assert.Equal("Zero", indicator.LinesSeries[1].Name);
+    }
+
+    [Fact]
+    public void CwtIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        // scale=2: windowSize=13 bars needed
+        var indicator = new CwtIndicator { Scale = 2.0 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        int windowSize = indicator.MinHistoryDepths;
+
+        for (int i = 0; i < windowSize; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 105 + i, 95 - i, 100 + i);
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // After windowSize bars, should have valid (non-cold) output
+        double val = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(val), "Output must be finite after warmup");
+        Assert.True(val >= 0.0, $"CWT magnitude {val} must be >= 0");
+    }
+
+    [Fact]
+    public void CwtIndicator_ProcessUpdate_NewBar_AddsNewValue()
+    {
+        var indicator = new CwtIndicator { Scale = 2.0 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        // Feed windowSize historical bars
+        int windowSize = indicator.MinHistoryDepths;
+        for (int i = 0; i < windowSize; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 105, 95, 100 + i);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        // Feed a new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(windowSize), 0, 106, 96, 103);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(windowSize + 1, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void CwtIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new CwtIndicator { Scale = 2.0 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 0, 105, 95, 100);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+
+        // 2 values: one historical, one intra-bar update
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void CwtIndicator_ZeroLine_IsAlwaysZero()
+    {
+        var indicator = new CwtIndicator { Scale = 2.0 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        int windowSize = indicator.MinHistoryDepths;
+        for (int i = 0; i < windowSize + 5; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 105, 95, 100 + i);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        // Zero reference line should always be 0
+        for (int i = 0; i < indicator.LinesSeries[1].Count; i++)
+        {
+            double zero = indicator.LinesSeries[1].GetValue(i);
+            Assert.Equal(0.0, zero, 1e-10);
+        }
+    }
+
+    [Fact]
+    public void CwtIndicator_DifferentSourceType_Works()
+    {
+        var indicator = new CwtIndicator { Scale = 2.0, Source = SourceType.High };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        int windowSize = indicator.MinHistoryDepths;
+        for (int i = 0; i < windowSize; i++)
+        {
+            // High = 110+i, Low = 90, Close = 100
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 0, 110 + i, 90, 100);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double val = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(val));
+        Assert.True(val >= 0.0);
+    }
+
+    [Fact]
+    public void CwtIndicator_OutputNonNegative_AfterManyBars()
+    {
+        var indicator = new CwtIndicator { Scale = 3.0 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 73001);
+        var bars = gbm.Fetch(100, now.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Close.Count; i++)
+        {
+            double price = bars.Close[i].Value;
+            indicator.HistoricalData.AddBar(
+                new DateTime(bars.Close[i].Time, DateTimeKind.Utc),
+                0, price * 1.01, price * 0.99, price);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        // Check all computed values are >= 0
+        for (int i = 0; i < indicator.LinesSeries[0].Count; i++)
+        {
+            double val = indicator.LinesSeries[0].GetValue(i);
+            Assert.True(val >= 0.0, $"CWT magnitude {val} at index {i} must be >= 0");
+        }
+    }
+}

lib/numerics/cwt/Cwt.Quantower.cs

@@ -0,0 +1,69 @@
+using System.Drawing;
+using TradingPlatform.BusinessLayer;
+using static QuanTAlib.IndicatorExtensions;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// CWT (Continuous Wavelet Transform) Quantower indicator.
+/// Computes the Morlet CWT magnitude at a specified scale, providing
+/// time-localized frequency-band energy decomposition.
+/// </summary>
+public class CwtIndicator : Indicator, IWatchlistIndicator
+{
+    [DataSourceInput]
+    public SourceType Source { get; set; } = SourceType.Close;
+
+    [InputParameter("Scale", sortIndex: 0, minimum: 0.5, maximum: 200.0, increment: 0.5, decimalPlaces: 1)]
+    public double Scale { get; set; } = 10.0;
+
+    [InputParameter("Omega0 (Central Frequency)", sortIndex: 1, minimum: 1.0, maximum: 20.0, increment: 0.5, decimalPlaces: 1)]
+    public double Omega0 { get; set; } = 6.0;
+
+    [InputParameter("Show Cold Values", sortIndex: 100)]
+    public bool ShowColdValues { get; set; } = true;
+
+    private Cwt? _cwt;
+    private Func<IHistoryItem, double>? _selector;
+
+    public int MinHistoryDepths => (int)(2 * Math.Round(3.0 * Scale) + 1);
+    public override string ShortName => $"CWT({Scale:G},{Omega0:G})";
+
+    public CwtIndicator()
+    {
+        Name = "CWT - Continuous Wavelet Transform";
+        Description = "Morlet CWT magnitude at a specified scale — time-frequency decomposition";
+        SeparateWindow = true;
+        OnBackGround = true;
+    }
+
+    protected override void OnInit()
+    {
+        _cwt = new Cwt(Scale, Omega0);
+        _selector = Source.GetPriceSelector();
+
+        AddLineSeries(new LineSeries("CWT Magnitude", Color.Cyan, 2, LineStyle.Solid));
+        // Reference level at 0 (baseline)
+        AddLineSeries(new LineSeries("Zero", Color.Gray, 1, LineStyle.Dash));
+    }
+
+    protected override void OnUpdate(UpdateArgs args)
+    {
+        if (_cwt == null || _selector == null)
+        {
+            return;
+        }
+
+        var item = HistoricalData[0, SeekOriginHistory.End];
+        double value = _selector(item);
+        bool isNew = args.IsNewBar();
+
+        TValue input = new(item.TimeLeft, value);
+        _cwt.Update(input, isNew);
+
+        bool isHot = _cwt.IsHot;
+
+        LinesSeries[0].SetValue(_cwt.Last.Value, isHot, ShowColdValues);
+        LinesSeries[1].SetValue(0.0, isHot, ShowColdValues);
+    }
+}

lib/numerics/cwt/Cwt.Tests.cs

@@ -0,0 +1,609 @@
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class CwtTests
+{
+    private const double Tolerance = 1e-10;
+
+    // ─── A) Constructor validation ────────────────────────────────────────────
+
+    [Fact]
+    public void Constructor_DefaultParameters_SetsProperties()
+    {
+        var indicator = new Cwt();
+        Assert.Equal("Cwt(10,6)", indicator.Name);
+        Assert.False(indicator.IsHot);
+    }
+
+    [Fact]
+    public void Constructor_CustomParameters_SetsName()
+    {
+        var indicator = new Cwt(scale: 20.0, omega0: 5.0);
+        Assert.Equal("Cwt(20,5)", indicator.Name);
+    }
+
+    [Fact]
+    public void Constructor_ZeroScale_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Cwt(scale: 0.0));
+        Assert.Equal("scale", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_NegativeScale_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Cwt(scale: -1.0));
+        Assert.Equal("scale", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_ZeroOmega_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Cwt(omega0: 0.0));
+        Assert.Equal("omega0", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_NegativeOmega_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new Cwt(omega0: -6.0));
+        Assert.Equal("omega0", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_WarmupPeriod_IsWindowSize()
+    {
+        // windowSize = 2*round(3*scale)+1 = 2*30+1 = 61 for scale=10
+        var indicator = new Cwt(scale: 10.0);
+        Assert.Equal(61, indicator.WarmupPeriod);
+    }
+
+    [Fact]
+    public void Constructor_SmallScale_CorrectWarmup()
+    {
+        // scale=1: halfWindow=round(3)=3, windowSize=7
+        var indicator = new Cwt(scale: 1.0);
+        Assert.Equal(7, indicator.WarmupPeriod);
+    }
+
+    // ─── B) Basic calculation ─────────────────────────────────────────────────
+
+    [Fact]
+    public void Update_ReturnsValidTValue()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        var input = new TValue(time, 100.0);
+        var result = indicator.Update(input);
+        Assert.Equal(input.Time, result.Time);
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Update_Output_IsNonNegative()
+    {
+        // CWT magnitude is always >= 0
+        var indicator = new Cwt(scale: 3.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70001);
+        var bars = gbm.Fetch(windowSize + 10, time.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Close.Count; i++)
+        {
+            indicator.Update(bars.Close[i]);
+            Assert.True(indicator.Last.Value >= 0.0,
+                $"CWT magnitude must be >= 0, got {indicator.Last.Value} at bar {i}");
+        }
+    }
+
+    [Fact]
+    public void Last_IsAccessible_AfterUpdate()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        indicator.Update(new TValue(time, 50.0));
+        Assert.NotEqual(default, indicator.Last);
+    }
+
+    [Fact]
+    public void Name_Accessible()
+    {
+        var indicator = new Cwt(scale: 5.0, omega0: 6.0);
+        Assert.NotNull(indicator.Name);
+        Assert.Contains("Cwt", indicator.Name, StringComparison.Ordinal);
+    }
+
+    // ─── C) State + bar correction ────────────────────────────────────────────
+
+    [Fact]
+    public void Update_IsNewTrue_AdvancesState()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70002);
+        var bars = gbm.Fetch(windowSize + 5, time.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < windowSize; i++)
+        {
+            indicator.Update(bars.Close[i]);
+        }
+
+        double before = indicator.Last.Value;
+        indicator.Update(new TValue(time.AddMinutes(windowSize), 9999.0), true);
+        double after = indicator.Last.Value;
+
+        // Extreme new value should change the output
+        Assert.True(double.IsFinite(after));
+        // Values may differ (9999 vs GBM prices)
+        _ = before; // consumed
+    }
+
+    [Fact]
+    public void Update_IsNewFalse_RewritesLastBar()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70003);
+        var bars = gbm.Fetch(windowSize + 2, time.Ticks, TimeSpan.FromMinutes(1));
+
+        // Fill to warmup
+        for (int i = 0; i < windowSize; i++)
+        {
+            indicator.Update(bars.Close[i]);
+        }
+
+        // New bar with extreme value A
+        indicator.Update(new TValue(time.AddMinutes(windowSize), 9999.0), true);
+        double valueA = indicator.Last.Value;
+
+        // Correct same bar with a different extreme value B
+        indicator.Update(new TValue(time.AddMinutes(windowSize), 0.001), false);
+        double valueB = indicator.Last.Value;
+
+        Assert.NotEqual(valueA, valueB, 1e-6);
+    }
+
+    [Fact]
+    public void Update_IterativeCorrection_RestoresState()
+    {
+        var time = DateTime.UtcNow;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70004);
+        int count = 30;
+        var bars = gbm.Fetch(count, time.Ticks, TimeSpan.FromMinutes(1));
+
+        // Streaming without corrections
+        var straight = new Cwt(scale: 2.0);
+        for (int i = 0; i < bars.Close.Count; i++)
+        {
+            straight.Update(bars.Close[i]);
+        }
+
+        double finalStraight = straight.Last.Value;
+
+        // With corrections (wrong → corrected)
+        var corrected = new Cwt(scale: 2.0);
+        for (int i = 0; i < bars.Close.Count; i++)
+        {
+            corrected.Update(new TValue(bars.Close[i].Time, 999.0), true);
+            corrected.Update(bars.Close[i], false);
+        }
+
+        Assert.Equal(finalStraight, corrected.Last.Value, Tolerance);
+    }
+
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70005);
+        var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Close.Count; i++)
+        {
+            indicator.Update(bars.Close[i]);
+        }
+
+        Assert.True(indicator.IsHot);
+
+        indicator.Reset();
+
+        Assert.False(indicator.IsHot);
+        Assert.Equal(default, indicator.Last);
+    }
+
+    // ─── D) Warmup / convergence ──────────────────────────────────────────────
+
+    [Fact]
+    public void IsHot_FlipsAtWindowSize()
+    {
+        // scale=2: halfWindow=round(6)=6, windowSize=13
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        for (int i = 0; i < windowSize - 1; i++)
+        {
+            indicator.Update(new TValue(time.AddMinutes(i), 100.0 + i));
+            Assert.False(indicator.IsHot, $"Should not be hot at bar {i + 1}");
+        }
+
+        indicator.Update(new TValue(time.AddMinutes(windowSize - 1), 100.0 + windowSize));
+        Assert.True(indicator.IsHot, "Should be hot after windowSize bars");
+    }
+
+    [Fact]
+    public void WarmupPeriod_ScaleDependent()
+    {
+        // scale=5: halfWindow=round(15)=15, windowSize=31
+        var ind5 = new Cwt(scale: 5.0);
+        Assert.Equal(31, ind5.WarmupPeriod);
+
+        // scale=0.5: halfWindow=round(1.5)=2, windowSize=5
+        var ind05 = new Cwt(scale: 0.5);
+        Assert.Equal(5, ind05.WarmupPeriod);
+    }
+
+    // ─── E) Robustness ────────────────────────────────────────────────────────
+
+    [Fact]
+    public void Update_NaN_UsesLastValidValue()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        // Fill to hot
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70006);
+        var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
+        for (int i = 0; i < windowSize; i++)
+        {
+            indicator.Update(bars.Close[i]);
+        }
+
+        double before = indicator.Last.Value;
+
+        indicator.Update(new TValue(time.AddMinutes(windowSize), double.NaN));
+        Assert.Equal(before, indicator.Last.Value, Tolerance);
+    }
+
+    [Fact]
+    public void Update_PositiveInfinity_UsesLastValidValue()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70007);
+        var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
+        for (int i = 0; i < windowSize; i++)
+        {
+            indicator.Update(bars.Close[i]);
+        }
+
+        double before = indicator.Last.Value;
+        indicator.Update(new TValue(time.AddMinutes(windowSize), double.PositiveInfinity));
+        Assert.Equal(before, indicator.Last.Value, Tolerance);
+    }
+
+    [Fact]
+    public void Update_NegativeInfinity_UsesLastValidValue()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70008);
+        var bars = gbm.Fetch(windowSize, time.Ticks, TimeSpan.FromMinutes(1));
+        for (int i = 0; i < windowSize; i++)
+        {
+            indicator.Update(bars.Close[i]);
+        }
+
+        double before = indicator.Last.Value;
+        indicator.Update(new TValue(time.AddMinutes(windowSize), double.NegativeInfinity));
+        Assert.Equal(before, indicator.Last.Value, Tolerance);
+    }
+
+    [Fact]
+    public void Update_BatchNaN_AlwaysFinite()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        var time = DateTime.UtcNow;
+
+        double[] prices = { 100.0, double.NaN, 102.0, double.NaN, 98.0, 105.0, 103.0, 99.0, 101.0, 104.0, 97.0, 106.0, 108.0 };
+        for (int i = 0; i < prices.Length; i++)
+        {
+            var result = indicator.Update(new TValue(time.AddMinutes(i), prices[i]));
+            Assert.True(double.IsFinite(result.Value), $"Output must be finite at {i}, got {result.Value}");
+        }
+    }
+
+    // ─── F) Consistency: batch == streaming == span == eventing ──────────────
+
+    [Fact]
+    public void AllModes_ConsistencyCheck()
+    {
+        int scale = 3;
+        int count = 80;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70009);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var source = bars.Close;
+
+        // Streaming
+        var streaming = new Cwt(scale);
+        for (int i = 0; i < source.Count; i++)
+        {
+            streaming.Update(source[i]);
+        }
+
+        // Batch (TSeries)
+        var batch = Cwt.Batch(source, scale);
+
+        // Span
+        var rawValues = new double[source.Count];
+        for (int i = 0; i < source.Count; i++)
+        {
+            rawValues[i] = source[i].Value;
+        }
+
+        var spanOutput = new double[source.Count];
+        Cwt.Batch(rawValues, spanOutput, scale);
+
+        // Eventing
+        var eventResults = new List<double>();
+        var eventSource = new TSeries();
+        var eventIndicator = new Cwt(eventSource, scale);
+        eventIndicator.Pub += (object? s, in TValueEventArgs e) => eventResults.Add(e.Value.Value);
+
+        for (int i = 0; i < source.Count; i++)
+        {
+            eventSource.Add(source[i], true);
+        }
+
+        // Verify last value matches all modes
+        double streamingLast = streaming.Last.Value;
+        double batchLast = batch[source.Count - 1].Value;
+        double spanLast = spanOutput[source.Count - 1];
+        double eventLast = eventResults[^1];
+
+        Assert.Equal(streamingLast, batchLast, Tolerance);
+        Assert.Equal(streamingLast, spanLast, Tolerance);
+        Assert.Equal(streamingLast, eventLast, Tolerance);
+    }
+
+    [Fact]
+    public void Streaming_VsBatch_AllValues_Match()
+    {
+        int count = 80;
+        double scale = 2.0;
+        var gbm = new GBM(startPrice: 50, mu: 0.0, sigma: 0.3, seed: 70010);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var source = bars.Close;
+
+        var streaming = new Cwt(scale);
+        var streamingVals = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            streaming.Update(source[i]);
+            streamingVals[i] = streaming.Last.Value;
+        }
+
+        var batch = Cwt.Batch(source, scale);
+
+        for (int i = 0; i < count; i++)
+        {
+            Assert.Equal(streamingVals[i], batch[i].Value, Tolerance);
+        }
+    }
+
+    // ─── G) Span API tests ────────────────────────────────────────────────────
+
+    [Fact]
+    public void Batch_Span_EmptySource_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() =>
+            Cwt.Batch([], Array.Empty<double>()));
+        Assert.Equal("source", ex.ParamName);
+    }
+
+    [Fact]
+    public void Batch_Span_OutputTooShort_ThrowsArgumentException()
+    {
+        double[] src = { 1.0, 2.0, 3.0 };
+        double[] dst = new double[2];
+        var ex = Assert.Throws<ArgumentException>(() =>
+            Cwt.Batch(src, dst));
+        Assert.Equal("output", ex.ParamName);
+    }
+
+    [Fact]
+    public void Batch_Span_InvalidScale_ThrowsArgumentException()
+    {
+        double[] src = { 1.0, 2.0, 3.0 };
+        double[] dst = new double[3];
+        var ex = Assert.Throws<ArgumentException>(() =>
+            Cwt.Batch(src, dst, scale: 0.0));
+        Assert.Equal("scale", ex.ParamName);
+    }
+
+    [Fact]
+    public void Batch_Span_InvalidOmega_ThrowsArgumentException()
+    {
+        double[] src = { 1.0, 2.0, 3.0 };
+        double[] dst = new double[3];
+        var ex = Assert.Throws<ArgumentException>(() =>
+            Cwt.Batch(src, dst, omega0: -1.0));
+        Assert.Equal("omega0", ex.ParamName);
+    }
+
+    [Fact]
+    public void Batch_Span_OutputIsNonNegative()
+    {
+        int count = 100;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70011);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        double[] src = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            src[i] = bars.Close[i].Value;
+        }
+
+        double[] dst = new double[count];
+        Cwt.Batch(src, dst, scale: 3.0);
+
+        foreach (double v in dst)
+        {
+            Assert.True(v >= 0.0, $"CWT magnitude {v} must be >= 0");
+        }
+    }
+
+    [Fact]
+    public void Batch_Span_HandlesNaN()
+    {
+        int windowSize = 7; // scale=1: 2*3+1=7
+        double[] src = new double[windowSize + 5];
+        for (int i = 0; i < src.Length; i++)
+        {
+            src[i] = 100.0 + i;
+        }
+
+        src[3] = double.NaN;
+        double[] dst = new double[src.Length];
+        Cwt.Batch(src, dst, scale: 1.0);
+
+        foreach (double v in dst)
+        {
+            Assert.True(double.IsFinite(v), $"Span output should always be finite, got {v}");
+        }
+    }
+
+    [Fact]
+    public void Batch_Span_NoStackOverflow_LargeScale()
+    {
+        // scale=40: halfWindow=120, windowSize=241 → uses ArrayPool (>128)
+        int count = 500;
+        double[] src = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            src[i] = 100.0 + Math.Sin(i * 0.1) * 10.0;
+        }
+
+        double[] dst = new double[count];
+        // Should not throw StackOverflowException
+        Cwt.Batch(src, dst, scale: 40.0);
+
+        foreach (double v in dst)
+        {
+            Assert.True(double.IsFinite(v));
+        }
+    }
+
+    [Fact]
+    public void Batch_Span_MatchesStreaming()
+    {
+        int count = 60;
+        double scale = 2.0;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.25, seed: 70012);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        double[] src = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            src[i] = bars.Close[i].Value;
+        }
+
+        double[] spanOut = new double[count];
+        Cwt.Batch(src, spanOut, scale: scale);
+
+        var streaming = new Cwt(scale);
+        for (int i = 0; i < count; i++)
+        {
+            streaming.Update(bars.Close[i]);
+            Assert.Equal(streaming.Last.Value, spanOut[i], Tolerance);
+        }
+    }
+
+    // ─── H) Chainability ──────────────────────────────────────────────────────
+
+    [Fact]
+    public void Pub_EventFires()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        int count = 0;
+        indicator.Pub += (object? sender, in TValueEventArgs args) => count++;
+
+        var time = DateTime.UtcNow;
+        for (int i = 0; i < 5; i++)
+        {
+            indicator.Update(new TValue(time.AddMinutes(i), 100.0 + i));
+        }
+
+        Assert.Equal(5, count);
+    }
+
+    [Fact]
+    public void Chaining_Constructor_Works()
+    {
+        double scale = 2.0;
+        var source = new TSeries();
+        var indicator = new Cwt(source, scale);
+        int windowSize = indicator.WarmupPeriod;
+
+        var time = DateTime.UtcNow;
+        for (int i = 0; i < windowSize; i++)
+        {
+            source.Add(new TValue(time.AddMinutes(i), 100.0 + i), true);
+        }
+
+        Assert.True(indicator.IsHot);
+        Assert.True(indicator.Last.Value >= 0.0);
+    }
+
+    [Fact]
+    public void Pub_EventValue_MatchesLast()
+    {
+        var indicator = new Cwt(scale: 2.0);
+        TValue? lastEvent = null;
+        indicator.Pub += (object? s, in TValueEventArgs e) => lastEvent = e.Value;
+
+        var time = DateTime.UtcNow;
+        int windowSize = indicator.WarmupPeriod;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70013);
+        var bars = gbm.Fetch(windowSize + 2, time.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Close.Count; i++)
+        {
+            indicator.Update(bars.Close[i]);
+        }
+
+        Assert.NotNull(lastEvent);
+        Assert.Equal(indicator.Last.Value, lastEvent.Value.Value, Tolerance);
+    }
+
+    // ─── Additional: static Calculate method ─────────────────────────────────
+
+    [Fact]
+    public void Calculate_StaticMethod_ReturnsTuple()
+    {
+        int count = 80;
+        double scale = 3.0;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 70014);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var (results, instance) = Cwt.Calculate(bars.Close, scale);
+
+        Assert.Equal(count, results.Count);
+        Assert.Equal(results[^1].Value, instance.Last.Value, Tolerance);
+    }
+}

lib/numerics/cwt/Cwt.Validation.Tests.cs

@@ -0,0 +1,282 @@
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+/// <summary>
+/// CWT validation tests — verifies known wavelet responses against analytical results.
+/// Since no external reference library implements CWT, we validate against:
+/// 1. Zero-input → zero output (linearity)
+/// 2. Constant input → near-zero output (wavelets have zero mean, so DC is rejected)
+/// 3. Sinusoidal resonance: CWT at matching scale produces larger magnitude than at non-matching scale
+/// 4. Output non-negativity (magnitude is always >= 0)
+/// 5. Determinism (same input always produces same output)
+/// 6. Batch vs streaming consistency
+/// </summary>
+public class CwtValidationTests
+{
+    private const double Tolerance = 1e-10;
+    private const double LooseTolerance = 1e-6;
+
+    // ─── Zero-mean property (DC rejection) ───────────────────────────────────
+
+    [Fact]
+    public void Cwt_ConstantInput_NearZero()
+    {
+        // Morlet wavelet has zero mean → convolution with constant signal ≈ 0
+        // (not exactly 0 due to finite window, but very small relative to signal amplitude)
+        double scale = 5.0;
+        var indicator = new Cwt(scale);
+        int windowSize = indicator.WarmupPeriod;
+        var time = DateTime.UtcNow;
+
+        // Feed constant value = 100.0 for full window + extra bars
+        for (int i = 0; i < windowSize + 10; i++)
+        {
+            indicator.Update(new TValue(time.AddSeconds(i), 100.0));
+        }
+
+        Assert.True(indicator.IsHot);
+        // Output should be very small relative to input amplitude (100.0)
+        // Due to finite window truncation, Morlet real part sums are not exactly 0,
+        // but the value should be negligible compared to signal energy.
+        Assert.True(indicator.Last.Value < 5.0,
+            $"Constant input should give near-zero CWT, got {indicator.Last.Value}");
+    }
+
+    [Fact]
+    public void Cwt_ZeroInput_OutputIsZero()
+    {
+        // Zero signal → zero output (by linearity)
+        double scale = 5.0;
+        var indicator = new Cwt(scale);
+        int windowSize = indicator.WarmupPeriod;
+        var time = DateTime.UtcNow;
+
+        for (int i = 0; i < windowSize + 5; i++)
+        {
+            indicator.Update(new TValue(time.AddSeconds(i), 0.0));
+        }
+
+        Assert.True(indicator.IsHot);
+        Assert.Equal(0.0, indicator.Last.Value, LooseTolerance);
+    }
+
+    // ─── Resonance: matching scale produces peak response ────────────────────
+
+    [Fact]
+    public void Cwt_SinusoidalResonance_MatchingScaleHigher()
+    {
+        // A pure sine wave with period P should give maximum CWT magnitude at
+        // scale s ≈ P*omega0/(2π). With omega0=6: s ≈ P/1.047
+        // We test: scale_match gives strictly larger magnitude than scale_mismatch
+        // on the same sinusoidal input.
+
+        double omega0 = 6.0;
+        double targetPeriod = 10.0; // 10-bar sine wave
+        double matchingScale = targetPeriod * omega0 / (2.0 * Math.PI); // ≈ 9.55
+        double mismatchScale = 2.0; // very different scale
+
+        int count = 300;
+        var time = DateTime.UtcNow;
+
+        var matchIndicator = new Cwt(matchingScale, omega0);
+        var mismatchIndicator = new Cwt(mismatchScale, omega0);
+
+        for (int i = 0; i < count; i++)
+        {
+            double signal = Math.Sin(2.0 * Math.PI * i / targetPeriod);
+            var tv = new TValue(time.AddSeconds(i), signal);
+            matchIndicator.Update(tv);
+            mismatchIndicator.Update(tv);
+        }
+
+        Assert.True(matchIndicator.IsHot);
+        Assert.True(mismatchIndicator.IsHot);
+
+        // Average magnitude over last half to smooth fluctuations
+        // Reset and recompute for clean average
+        var matchIndicator2 = new Cwt(matchingScale, omega0);
+        var mismatchIndicator2 = new Cwt(mismatchScale, omega0);
+
+        double sumMatch = 0.0, sumMismatch = 0.0;
+        int nMatch = 0, nMismatch = 0;
+        int halfCount = count / 2;
+
+        for (int i = 0; i < count; i++)
+        {
+            double signal = Math.Sin(2.0 * Math.PI * i / targetPeriod);
+            var tv = new TValue(time.AddSeconds(i), signal);
+            matchIndicator2.Update(tv);
+            mismatchIndicator2.Update(tv);
+
+            if (i >= halfCount)
+            {
+                if (matchIndicator2.IsHot)
+                {
+                    sumMatch += matchIndicator2.Last.Value;
+                    nMatch++;
+                }
+
+                if (mismatchIndicator2.IsHot)
+                {
+                    sumMismatch += mismatchIndicator2.Last.Value;
+                    nMismatch++;
+                }
+            }
+        }
+
+        double avgMatch = nMatch > 0 ? sumMatch / nMatch : 0.0;
+        double avgMismatch = nMismatch > 0 ? sumMismatch / nMismatch : 0.0;
+
+        Assert.True(avgMatch > avgMismatch,
+            $"Matching scale ({matchingScale:F2}) avg={avgMatch:F4} should exceed " +
+            $"mismatch scale ({mismatchScale:F2}) avg={avgMismatch:F4}");
+    }
+
+    // ─── Non-negativity invariant ─────────────────────────────────────────────
+
+    [Fact]
+    public void Cwt_OutputAlwaysNonNegative_GbmData()
+    {
+        int count = 300;
+        double scale = 8.0;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 72001);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var indicator = new Cwt(scale);
+        for (int i = 0; i < count; i++)
+        {
+            indicator.Update(bars.Close[i]);
+            Assert.True(indicator.Last.Value >= 0.0,
+                $"CWT magnitude negative at bar {i}: {indicator.Last.Value}");
+        }
+    }
+
+    [Fact]
+    public void Cwt_OutputAlwaysNonNegative_SpanBatch()
+    {
+        int count = 200;
+        double scale = 5.0;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.25, seed: 72002);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        double[] src = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            src[i] = bars.Close[i].Value;
+        }
+
+        double[] dst = new double[count];
+        Cwt.Batch(src, dst, scale);
+
+        foreach (double v in dst)
+        {
+            Assert.True(v >= 0.0, $"Span CWT magnitude {v} must be >= 0");
+        }
+    }
+
+    // ─── Determinism ──────────────────────────────────────────────────────────
+
+    [Fact]
+    public void Cwt_Deterministic_SameInput_SameOutput()
+    {
+        int count = 100;
+        double scale = 6.0;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72003);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var ind1 = new Cwt(scale);
+        var ind2 = new Cwt(scale);
+
+        for (int i = 0; i < count; i++)
+        {
+            ind1.Update(bars.Close[i]);
+            ind2.Update(bars.Close[i]);
+            Assert.Equal(ind1.Last.Value, ind2.Last.Value, Tolerance);
+        }
+    }
+
+    // ─── Scale effect: larger scale → lower frequency ─────────────────────────
+
+    [Fact]
+    public void Cwt_DifferentScales_DifferentOutput()
+    {
+        int count = 100;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72004);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var ind3 = new Cwt(scale: 3.0);
+        var ind10 = new Cwt(scale: 10.0);
+
+        for (int i = 0; i < count; i++)
+        {
+            ind3.Update(bars.Close[i]);
+            ind10.Update(bars.Close[i]);
+        }
+
+        // Different scales must produce different outputs (unless degenerate input)
+        Assert.NotEqual(ind3.Last.Value, ind10.Last.Value, 1e-6);
+    }
+
+    // ─── Batch vs streaming full-array consistency ───────────────────────────
+
+    [Fact]
+    public void Cwt_Batch_MatchesStreaming_AllValues()
+    {
+        int count = 150;
+        double scale = 4.0;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.25, seed: 72005);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        double[] rawValues = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            rawValues[i] = bars.Close[i].Value;
+        }
+
+        var tseriesResult = Cwt.Batch(bars.Close, scale);
+        double[] spanResult = new double[count];
+        Cwt.Batch(rawValues, spanResult, scale);
+
+        for (int i = 0; i < count; i++)
+        {
+            Assert.Equal(tseriesResult[i].Value, spanResult[i], Tolerance);
+        }
+    }
+
+    // ─── Large dataset: stable ────────────────────────────────────────────────
+
+    [Fact]
+    public void Cwt_LargeDataset_Stable()
+    {
+        int count = 2000;
+        double scale = 10.0;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 72006);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var indicator = new Cwt(scale);
+
+        for (int i = 0; i < count; i++)
+        {
+            indicator.Update(bars.Close[i]);
+            double v = indicator.Last.Value;
+            Assert.True(double.IsFinite(v) && v >= 0.0,
+                $"Invalid output {v} at bar {i}");
+        }
+    }
+
+    // ─── Period=1 trivial: single sample → zero (warmup) ─────────────────────
+
+    [Fact]
+    public void Cwt_SingleSampleBeforeWarmup_OutputZero()
+    {
+        var indicator = new Cwt(scale: 5.0);
+        var time = DateTime.UtcNow;
+
+        // Only one update: should NOT be hot
+        indicator.Update(new TValue(time, 100.0));
+
+        Assert.False(indicator.IsHot);
+        Assert.Equal(0.0, indicator.Last.Value, Tolerance);
+    }
+}

lib/numerics/cwt/Cwt.cs

@@ -0,0 +1,353 @@
+// CWT: Continuous Wavelet Transform
+// Convolves a signal with a scaled Morlet wavelet to extract spectral energy
+// at a specific frequency band (determined by the scale parameter).
+// Algorithm: precomputed Morlet kernel × RingBuffer sliding window.
+// Half-window K = round(3*scale) — captures 99.7% of Gaussian envelope.
+// Output: |W(t,s)| = sqrt(Re² + Im²) / sqrt(scale).
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// CWT: Continuous Wavelet Transform
+/// Computes the Morlet CWT magnitude at a single scale, providing a
+/// time-localized frequency decomposition of the input series.
+/// </summary>
+/// <remarks>
+/// Key properties:
+/// - Output is the Morlet wavelet magnitude |W(t,s)| — non-negative
+/// - Half-window K = round(3*scale); warmup = 2K+1 samples
+/// - Normalization: 1/sqrt(s) preserves energy across scales
+/// - Omega0 = 6.0 (default) satisfies the admissibility condition
+/// - Scale-to-period: P ≈ 2π·s / ω0 (e.g., scale=10 → period ≈ 10.5 bars)
+/// - No allocation in Update (RingBuffer + precomputed kernel)
+/// </remarks>
+[SkipLocalsInit]
+public sealed class Cwt : AbstractBase
+{
+    private readonly int _windowSize;  // 2K+1 = 2*round(3*scale)+1
+    private readonly double[] _kernelReal;
+    private readonly double[] _kernelImag;
+    private readonly double _normFactor; // 1/sqrt(scale)
+    private readonly RingBuffer _buffer;
+
+    [StructLayout(LayoutKind.Auto)]
+    private record struct State(double LastValid);
+    private State _state, _p_state;
+
+    public override bool IsHot => _buffer.Count >= _windowSize;
+
+    /// <summary>
+    /// Initializes a new Cwt indicator.
+    /// </summary>
+    /// <param name="scale">Wavelet scale parameter (default 10.0). Controls the frequency band analyzed.
+    /// Scale-to-period: P ≈ 2π·scale/omega0. Must be > 0.</param>
+    /// <param name="omega0">Central frequency of the Morlet wavelet (default 6.0).
+    /// Must be > 0. Higher values give better frequency resolution (at cost of time resolution).</param>
+    public Cwt(double scale = 10.0, double omega0 = 6.0)
+    {
+        if (scale <= 0.0)
+        {
+            throw new ArgumentException("Scale must be > 0", nameof(scale));
+        }
+
+        if (omega0 <= 0.0)
+        {
+            throw new ArgumentException("Omega0 must be > 0", nameof(omega0));
+        }
+
+        int halfWindow = (int)Math.Round(3.0 * scale);
+        _windowSize = 2 * halfWindow + 1;
+        _normFactor = 1.0 / Math.Sqrt(scale);
+
+        // Precompute kernel: ψ(k/s) = exp(-k²/(2s²)) * (cos(ω₀k/s) - i·sin(ω₀k/s))
+        // Kernel is centered, k runs from -halfWindow..+halfWindow
+        // We store in order [0..windowSize-1] where index j maps to k = j - halfWindow
+        _kernelReal = new double[_windowSize];
+        _kernelImag = new double[_windowSize];
+        PrecomputeKernel(_kernelReal, _kernelImag, halfWindow, scale, omega0);
+
+        _buffer = new RingBuffer(_windowSize);
+        Name = $"Cwt({scale:G},{omega0:G})";
+        WarmupPeriod = _windowSize;
+        _state = new State(0.0);
+        _p_state = _state;
+    }
+
+    /// <summary>
+    /// Initializes a new Cwt indicator with source for event-based chaining.
+    /// </summary>
+    /// <param name="source">Source indicator for chaining</param>
+    /// <param name="scale">Wavelet scale parameter (default 10.0)</param>
+    /// <param name="omega0">Central frequency of the Morlet wavelet (default 6.0)</param>
+    public Cwt(ITValuePublisher source, double scale = 10.0, double omega0 = 6.0)
+        : this(scale, omega0)
+    {
+        source.Pub += HandleUpdate;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void HandleUpdate(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
+
+    /// <summary>
+    /// Precomputes the Morlet wavelet kernel weights for the given scale.
+    /// kernelReal[j] = exp(-t²/2) * cos(ω₀t),  t = (j - halfWindow) / scale
+    /// kernelImag[j] = exp(-t²/2) * sin(ω₀t),  t = (j - halfWindow) / scale
+    /// The kernel is complex-conjugate: the CWT convolution uses ψ*(k/s),
+    /// so both real and imaginary components are needed.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void PrecomputeKernel(
+        double[] kernelReal, double[] kernelImag,
+        int halfWindow, double scale, double omega0)
+    {
+        int windowSize = 2 * halfWindow + 1;
+        double invScale = 1.0 / scale;
+        for (int j = 0; j < windowSize; j++)
+        {
+            double t = (j - halfWindow) * invScale;
+            double gauss = Math.Exp(Math.FusedMultiplyAdd(-0.5, t * t, 0.0));
+            double phase = omega0 * t;
+            // Complex conjugate of e^{iω₀t}: cos(ω₀t) - i·sin(ω₀t)
+            kernelReal[j] = gauss * Math.Cos(phase);
+            kernelImag[j] = gauss * Math.Sin(phase);
+        }
+    }
+
+    /// <summary>
+    /// Computes the dot product of the ring buffer contents with the precomputed kernel.
+    /// Buffer[0] = oldest, Buffer[windowSize-1] = newest.
+    /// kernel[0] corresponds to k = -halfWindow (earliest offset).
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private double ComputeCwt()
+    {
+        var span = _buffer.GetSpan();
+        int n = span.Length;
+        double re = 0.0;
+        double im = 0.0;
+
+        // span[0] is the oldest sample, aligns with kernel[windowSize-1-?]
+        // The CWT formula: W(t,s) = (1/√s) Σ_k x[t-k]·ψ*(k/s)
+        // where k = -halfWindow..+halfWindow, and x[t-k] is stored oldest-first.
+        // span[j] = x[t - halfWindow + j]  (j=0: oldest = x[t-K], j=windowSize-1: newest = x[t+K])
+        // ψ*(k/s) at k = -halfWindow+j corresponds to kernelReal/Imag[j].
+        for (int j = 0; j < n; j++)
+        {
+            double v = span[j];
+            re = Math.FusedMultiplyAdd(v, _kernelReal[j], re);
+            im = Math.FusedMultiplyAdd(v, _kernelImag[j], im);
+        }
+
+        return Math.Sqrt(Math.FusedMultiplyAdd(re, re, im * im)) * _normFactor;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override TValue Update(TValue input, bool isNew = true)
+    {
+        if (isNew)
+        {
+            _p_state = _state;
+        }
+        else
+        {
+            _state = _p_state;
+        }
+
+        double value = input.Value;
+        double result;
+
+        if (double.IsFinite(value))
+        {
+            _buffer.Add(value, isNew);
+            if (IsHot)
+            {
+                result = ComputeCwt();
+                _state = new State(result);
+            }
+            else
+            {
+                result = _state.LastValid;
+            }
+        }
+        else
+        {
+            result = _state.LastValid;
+        }
+
+        Last = new TValue(input.Time, result);
+        PubEvent(Last, isNew);
+        return Last;
+    }
+
+    public override TSeries Update(TSeries source)
+    {
+        var result = new TSeries(source.Count);
+        ReadOnlySpan<double> values = source.Values;
+        ReadOnlySpan<long> times = source.Times;
+
+        for (int i = 0; i < source.Count; i++)
+        {
+            var tv = Update(new TValue(new DateTime(times[i], DateTimeKind.Utc), values[i]), true);
+            result.Add(tv, true);
+        }
+
+        return result;
+    }
+
+    public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
+    {
+        TimeSpan interval = step ?? TimeSpan.FromSeconds(1);
+        DateTime time = DateTime.UtcNow - (interval * source.Length);
+
+        for (int i = 0; i < source.Length; i++)
+        {
+            Update(new TValue(time, source[i]), true);
+            time += interval;
+        }
+    }
+
+    public static TSeries Batch(TSeries source, double scale = 10.0, double omega0 = 6.0)
+    {
+        var indicator = new Cwt(scale, omega0);
+        return indicator.Update(source);
+    }
+
+    /// <summary>
+    /// Calculates CWT magnitude over a span of values using a sliding Morlet convolution.
+    /// Uses stackalloc for kernel when windowSize &lt;= 256, otherwise ArrayPool.
+    /// </summary>
+    public static void Batch(
+        ReadOnlySpan<double> source, Span<double> output,
+        double scale = 10.0, double omega0 = 6.0)
+    {
+        if (source.Length == 0)
+        {
+            throw new ArgumentException("Source cannot be empty", nameof(source));
+        }
+
+        if (output.Length < source.Length)
+        {
+            throw new ArgumentException("Output length must be >= source length", nameof(output));
+        }
+
+        if (scale <= 0.0)
+        {
+            throw new ArgumentException("Scale must be > 0", nameof(scale));
+        }
+
+        if (omega0 <= 0.0)
+        {
+            throw new ArgumentException("Omega0 must be > 0", nameof(omega0));
+        }
+
+        int halfWindow = (int)Math.Round(3.0 * scale);
+        int windowSize = 2 * halfWindow + 1;
+        double normFactor = 1.0 / Math.Sqrt(scale);
+        double lastValid = 0.0;
+
+        const int StackallocThreshold = 128; // 128 doubles * 2 arrays = 2KB, safe margin
+
+        double[]? rentedReal = null;
+        double[]? rentedImag = null;
+        scoped Span<double> kReal;
+        scoped Span<double> kImag;
+
+        if (windowSize <= StackallocThreshold)
+        {
+            kReal = stackalloc double[windowSize];
+            kImag = stackalloc double[windowSize];
+        }
+        else
+        {
+            rentedReal = ArrayPool<double>.Shared.Rent(windowSize);
+            rentedImag = ArrayPool<double>.Shared.Rent(windowSize);
+            kReal = rentedReal.AsSpan(0, windowSize);
+            kImag = rentedImag.AsSpan(0, windowSize);
+        }
+
+        try
+        {
+            // Precompute kernel
+            double invScale = 1.0 / scale;
+            for (int j = 0; j < windowSize; j++)
+            {
+                double t = (j - halfWindow) * invScale;
+                double gauss = Math.Exp(Math.FusedMultiplyAdd(-0.5, t * t, 0.0));
+                double phase = omega0 * t;
+                kReal[j] = gauss * Math.Cos(phase);
+                kImag[j] = gauss * Math.Sin(phase);
+            }
+
+            // Sliding convolution
+            for (int i = 0; i < source.Length; i++)
+            {
+                double val = source[i];
+                if (!double.IsFinite(val))
+                {
+                    output[i] = lastValid;
+                    continue;
+                }
+
+                // We need windowSize samples ending at i (inclusive).
+                // If i < windowSize-1, the buffer is not full yet → return lastValid (0).
+                if (i < windowSize - 1)
+                {
+                    output[i] = lastValid;
+                    continue;
+                }
+
+                int start = i - windowSize + 1;
+                double re = 0.0;
+                double im = 0.0;
+
+                for (int j = 0; j < windowSize; j++)
+                {
+                    double v = source[start + j];
+                    if (!double.IsFinite(v))
+                    {
+                        v = lastValid;
+                    }
+
+                    re = Math.FusedMultiplyAdd(v, kReal[j], re);
+                    im = Math.FusedMultiplyAdd(v, kImag[j], im);
+                }
+
+                double magnitude = Math.Sqrt(Math.FusedMultiplyAdd(re, re, im * im)) * normFactor;
+                lastValid = magnitude;
+                output[i] = magnitude;
+            }
+        }
+        finally
+        {
+            if (rentedReal != null)
+            {
+                ArrayPool<double>.Shared.Return(rentedReal);
+            }
+
+            if (rentedImag != null)
+            {
+                ArrayPool<double>.Shared.Return(rentedImag);
+            }
+        }
+    }
+
+    public static (TSeries Results, Cwt Indicator) Calculate(
+        TSeries source, double scale = 10.0, double omega0 = 6.0)
+    {
+        var indicator = new Cwt(scale, omega0);
+        TSeries results = indicator.Update(source);
+        return (results, indicator);
+    }
+
+    public override void Reset()
+    {
+        _buffer.Clear();
+        _state = new State(0.0);
+        _p_state = _state;
+        Last = default;
+    }
+}