refactoring

lib/core/AbstractBase.cs

@@ -0,0 +1,69 @@
+using System;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// Abstract base class for all indicators.
+/// Enforces a consistent contract for State, Name, WarmupPeriod, and core methods.
+/// </summary>
+public abstract class AbstractBase : ITValuePublisher
+{
+    /// <summary>
+    /// Display name for the indicator.
+    /// </summary>
+    public string Name { get; protected set; } = string.Empty;
+
+    /// <summary>
+    /// Number of periods before the indicator is considered "hot" (valid).
+    /// </summary>
+    public int WarmupPeriod { get; protected set; }
+
+    /// <summary>
+    /// Current value of the indicator.
+    /// </summary>
+    public TValue Last { get; protected set; }
+
+    /// <summary>
+    /// True if the indicator has enough data to produce valid results.
+    /// </summary>
+    public abstract bool IsHot { get; }
+
+    /// <summary>
+    /// Event triggered when a new TValue is available.
+    /// </summary>
+    public event Action<TValue>? Pub;
+
+    /// <summary>
+    /// Helper to invoke the Pub event.
+    /// </summary>
+    protected void PubEvent(TValue value)
+    {
+        Pub?.Invoke(value);
+    }
+
+    /// <summary>
+    /// Initializes the indicator state using the provided history.
+    /// </summary>
+    /// <param name="source">Historical data</param>
+    public abstract void Prime(ReadOnlySpan<double> source);
+
+    /// <summary>
+    /// Updates the indicator with a single value.
+    /// </summary>
+    /// <param name="input">Input value</param>
+    /// <param name="isNew">True if this is a new bar, False if it's an update to the last bar</param>
+    /// <returns>Updated value</returns>
+    public abstract TValue Update(TValue input, bool isNew = true);
+
+    /// <summary>
+    /// Updates the indicator with a series of values.
+    /// </summary>
+    /// <param name="source">Input series</param>
+    /// <returns>Series of calculated values</returns>
+    public abstract TSeries Update(TSeries source);
+
+    /// <summary>
+    /// Resets the indicator to its initial state.
+    /// </summary>
+    public abstract void Reset();
+}

lib/core/simd/SimdExtensions.Tests.cs

@@ -525,6 +525,32 @@ public class SimdExtensionsTests
         Assert.Throws<ArgumentException>(() => SimdExtensions.Subtract(left, right, result));
     }
 
+    // DotProduct tests
+    [Fact]
+    public void DotProduct_SameLength_CorrectResult()
+    {
+        double[] a = [1.0, 2.0, 3.0];
+        double[] b = [4.0, 5.0, 6.0];
+        // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
+        Assert.Equal(32.0, SimdExtensions.DotProduct(a, b));
+    }
+
+    [Fact]
+    public void DotProduct_DifferentLengths_ThrowsArgumentException()
+    {
+        double[] a = [1.0, 2.0];
+        double[] b = [1.0];
+        Assert.Throws<ArgumentException>(() => SimdExtensions.DotProduct(a, b));
+    }
+
+    [Fact]
+    public void DotProduct_EmptySpans_ReturnsZero()
+    {
+        double[] a = [];
+        double[] b = [];
+        Assert.Equal(0.0, SimdExtensions.DotProduct(a, b));
+    }
+
     // Integration tests
     [Fact]
     public void SIMD_WorksWithTSeriesValues()

lib/core/tbar/tbar.cs

@@ -1,83 +1,83 @@
-using System.Runtime.CompilerServices;
-
-namespace QuanTAlib;
-
-/// <summary>
-/// A lightweight struct representing an OHLCV bar.
-/// Pure data type: 48 bytes (long + 5 doubles).
-/// </summary>
-[SkipLocalsInit]
-public readonly struct TBar : IEquatable<TBar>
-{
-    public readonly long Time;
-    public readonly double Open;
-    public readonly double High;
-    public readonly double Low;
-    public readonly double Close;
-    public readonly double Volume;
-
-    public DateTime AsDateTime => new(Time, DateTimeKind.Utc);
-
-    // TValue conversions (Zero-copy / lightweight creation)
-    public TValue O { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Open); }
-    public TValue H { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, High); }
-    public TValue L { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Low); }
-    public TValue C { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Close); }
-    public TValue V { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Volume); }
-
-    // Computed properties (calculated on demand, no storage overhead)
-    public double HL2 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (High + Low) * 0.5; }
-    public double OC2 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (Open + Close) * 0.5; }
-    public double OHL3 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (Open + High + Low) * 0.333333333333333333; }
-    public double HLC3 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (High + Low + Close) * 0.333333333333333333; }
-    public double OHLC4 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (Open + High + Low + Close) * 0.25; }
-    public double HLCC4 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (High + Low + Close + Close) * 0.25; }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public TBar(long time, double open, double high, double low, double close, double volume)
-    {
-        Time = time;
-        Open = open;
-        High = high;
-        Low = low;
-        Close = close;
-        Volume = volume;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public TBar(DateTime time, double open, double high, double low, double close, double volume)
-    {
-        Time = time.Ticks;
-        Open = open;
-        High = high;
-        Low = low;
-        Close = close;
-        Volume = volume;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator double(TBar bar) => bar.Close;
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator TValue(TBar bar) => new(bar.Time, bar.Close);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator DateTime(TBar bar) => new(bar.Time, DateTimeKind.Utc);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public override string ToString() => $"[{AsDateTime:yyyy-MM-dd HH:mm:ss}: O={Open:F2}, H={High:F2}, L={Low:F2}, C={Close:F2}, V={Volume:F2}]";
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool Equals(TBar other) =>
-        Time == other.Time &&
-        Open == other.Open &&
-        High == other.High &&
-        Low == other.Low &&
-        Close == other.Close &&
-        Volume == other.Volume;
-
-    public override bool Equals(object? obj) => obj is TBar other && Equals(other);
-    public override int GetHashCode() => HashCode.Combine(Time, Open, High, Low, Close, Volume);
-    public static bool operator ==(TBar left, TBar right) => left.Equals(right);
-    public static bool operator !=(TBar left, TBar right) => !left.Equals(right);
-}
+using System.Runtime.CompilerServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// A lightweight struct representing an OHLCV bar.
+/// Pure data type: 48 bytes (long + 5 doubles).
+/// </summary>
+[SkipLocalsInit]
+public readonly struct TBar : IEquatable<TBar>
+{
+    public readonly long Time;
+    public readonly double Open;
+    public readonly double High;
+    public readonly double Low;
+    public readonly double Close;
+    public readonly double Volume;
+
+    public DateTime AsDateTime => new(Time, DateTimeKind.Utc);
+
+    // TValue conversions (Zero-copy / lightweight creation)
+    public TValue O { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Open); }
+    public TValue H { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, High); }
+    public TValue L { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Low); }
+    public TValue C { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Close); }
+    public TValue V { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => new(Time, Volume); }
+
+    // Computed properties (calculated on demand, no storage overhead)
+    public double HL2 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (High + Low) * 0.5; }
+    public double OC2 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (Open + Close) * 0.5; }
+    public double OHL3 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (Open + High + Low) * 0.333333333333333333; }
+    public double HLC3 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (High + Low + Close) * 0.333333333333333333; }
+    public double OHLC4 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (Open + High + Low + Close) * 0.25; }
+    public double HLCC4 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (High + Low + Close + Close) * 0.25; }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TBar(long time, double open, double high, double low, double close, double volume)
+    {
+        Time = time;
+        Open = open;
+        High = high;
+        Low = low;
+        Close = close;
+        Volume = volume;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TBar(DateTime time, double open, double high, double low, double close, double volume)
+    {
+        Time = time.Ticks;
+        Open = open;
+        High = high;
+        Low = low;
+        Close = close;
+        Volume = volume;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator double(TBar bar) => bar.Close;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator TValue(TBar bar) => new(bar.Time, bar.Close);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator DateTime(TBar bar) => new(bar.Time, DateTimeKind.Utc);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override string ToString() => $"[{AsDateTime:yyyy-MM-dd HH:mm:ss}: O={Open:F2}, H={High:F2}, L={Low:F2}, C={Close:F2}, V={Volume:F2}]";
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Equals(TBar other) =>
+        Time == other.Time &&
+        Open == other.Open &&
+        High == other.High &&
+        Low == other.Low &&
+        Close == other.Close &&
+        Volume == other.Volume;
+
+    public override bool Equals(object? obj) => obj is TBar other && Equals(other);
+    public override int GetHashCode() => HashCode.Combine(Time, Open, High, Low, Close, Volume);
+    public static bool operator ==(TBar left, TBar right) => left.Equals(right);
+    public static bool operator !=(TBar left, TBar right) => !left.Equals(right);
+}

lib/core/tbarseries/tbarseries.cs

@@ -1,147 +1,147 @@
-using System.Collections;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace QuanTAlib;
-
-/// <summary>
-/// A high-performance OHLCV time series implementation using Structure of Arrays (SoA) layout.
-/// Stores Time, Open, High, Low, Close, Volume in separate contiguous arrays for SIMD efficiency.
-/// Exposes TSeries views for each component that share the underlying Time array.
-/// </summary>
-public class TBarSeries : IReadOnlyList<TBar>
-{
-    protected readonly List<long> _t;
-    protected readonly List<double> _o;
-    protected readonly List<double> _h;
-    protected readonly List<double> _l;
-    protected readonly List<double> _c;
-    protected readonly List<double> _v;
-
-    public string Name { get; set; } = "Bar";
-    public event Action<TBar>? Pub;
-
-    // Note: These views share underlying storage. Do not modify directly; use TBarSeries.Add() instead.
-    public TSeries Open { get; }
-    public TSeries High { get; }
-    public TSeries Low { get; }
-    public TSeries Close { get; }
-    public TSeries Volume { get; }
-    // Aliases for convenience
-    public TSeries O => Open;
-    public TSeries H => High;
-    public TSeries L => Low;
-    public TSeries C => Close;
-    public TSeries V => Volume;
-
-    public TBarSeries() : this(0)
-    {
-    }
-
-    public TBarSeries(int capacity)
-    {
-        _t = new List<long>(capacity);
-        _o = new List<double>(capacity);
-        _h = new List<double>(capacity);
-        _l = new List<double>(capacity);
-        _c = new List<double>(capacity);
-        _v = new List<double>(capacity);
-
-        Open = new TSeries(_t, _o) { Name = "Open" };
-        High = new TSeries(_t, _h) { Name = "High" };
-        Low = new TSeries(_t, _l) { Name = "Low" };
-        Close = new TSeries(_t, _c) { Name = "Close" };
-        Volume = new TSeries(_t, _v) { Name = "Volume" };
-    }
-
-    public int Count
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => _c.Count;
-    }
-
-    public TBar this[int index]
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => new(_t[index], _o[index], _h[index], _l[index], _c[index], _v[index]);
-    }
-
-    public TBar Last
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => _c.Count > 0 ? new(_t[^1], _o[^1], _h[^1], _l[^1], _c[^1], _v[^1]) : default;
-    }
-
-    public long LastTime { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _t.Count > 0 ? _t[^1] : 0; }
-    public double LastOpen { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _o.Count > 0 ? _o[^1] : double.NaN; }
-    public double LastHigh { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _h.Count > 0 ? _h[^1] : double.NaN; }
-    public double LastLow { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _l.Count > 0 ? _l[^1] : double.NaN; }
-    public double LastClose { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _c.Count > 0 ? _c[^1] : double.NaN; }
-    public double LastVolume { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _v.Count > 0 ? _v[^1] : double.NaN; }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(TBar bar, bool isNew = true)
-    {
-        if (isNew || _c.Count == 0)
-        {
-            _t.Add(bar.Time);
-            _o.Add(bar.Open);
-            _h.Add(bar.High);
-            _l.Add(bar.Low);
-            _c.Add(bar.Close);
-            _v.Add(bar.Volume);
-        }
-        else
-        {
-            int lastIdx = _c.Count - 1;
-            _t[lastIdx] = bar.Time;
-            _o[lastIdx] = bar.Open;
-            _h[lastIdx] = bar.High;
-            _l[lastIdx] = bar.Low;
-            _c[lastIdx] = bar.Close;
-            _v[lastIdx] = bar.Volume;
-        }
-
-        Pub?.Invoke(bar);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(long time, double open, double high, double low, double close, double volume, bool isNew = true) =>
-        Add(new TBar(time, open, high, low, close, volume), isNew);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(DateTime time, double open, double high, double low, double close, double volume, bool isNew = true) =>
-        Add(new TBar(time.Ticks, open, high, low, close, volume), isNew);
-
-    public void Add(IEnumerable<long> t, IEnumerable<double> o, IEnumerable<double> h, IEnumerable<double> l, IEnumerable<double> c, IEnumerable<double> v)
-    {
-        var tArr = t as long[] ?? t.ToArray();
-        var oArr = o as double[] ?? o.ToArray();
-        var hArr = h as double[] ?? h.ToArray();
-        var lArr = l as double[] ?? l.ToArray();
-        var cArr = c as double[] ?? c.ToArray();
-        var vArr = v as double[] ?? v.ToArray();
-
-        if (tArr.Length != oArr.Length || oArr.Length != hArr.Length ||
-            hArr.Length != lArr.Length || lArr.Length != cArr.Length ||
-            cArr.Length != vArr.Length)
-        {
-            throw new ArgumentException("All arrays must have the same length");
-        }
-
-        for (int i = 0; i < tArr.Length; i++)
-        {
-            Add(tArr[i], oArr[i], hArr[i], lArr[i], cArr[i], vArr[i]);
-        }
-    }
-
-    public IEnumerator<TBar> GetEnumerator()
-    {
-        for (int i = 0; i < _c.Count; i++)
-        {
-            yield return new TBar(_t[i], _o[i], _h[i], _l[i], _c[i], _v[i]);
-        }
-    }
-
-    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-}
+using System.Collections;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// A high-performance OHLCV time series implementation using Structure of Arrays (SoA) layout.
+/// Stores Time, Open, High, Low, Close, Volume in separate contiguous arrays for SIMD efficiency.
+/// Exposes TSeries views for each component that share the underlying Time array.
+/// </summary>
+public class TBarSeries : IReadOnlyList<TBar>
+{
+    protected readonly List<long> _t;
+    protected readonly List<double> _o;
+    protected readonly List<double> _h;
+    protected readonly List<double> _l;
+    protected readonly List<double> _c;
+    protected readonly List<double> _v;
+
+    public string Name { get; set; } = "Bar";
+    public event Action<TBar>? Pub;
+
+    // Note: These views share underlying storage. Do not modify directly; use TBarSeries.Add() instead.
+    public TSeries Open { get; }
+    public TSeries High { get; }
+    public TSeries Low { get; }
+    public TSeries Close { get; }
+    public TSeries Volume { get; }
+    // Aliases for convenience
+    public TSeries O => Open;
+    public TSeries H => High;
+    public TSeries L => Low;
+    public TSeries C => Close;
+    public TSeries V => Volume;
+
+    public TBarSeries() : this(0)
+    {
+    }
+
+    public TBarSeries(int capacity)
+    {
+        _t = new List<long>(capacity);
+        _o = new List<double>(capacity);
+        _h = new List<double>(capacity);
+        _l = new List<double>(capacity);
+        _c = new List<double>(capacity);
+        _v = new List<double>(capacity);
+
+        Open = new TSeries(_t, _o) { Name = "Open" };
+        High = new TSeries(_t, _h) { Name = "High" };
+        Low = new TSeries(_t, _l) { Name = "Low" };
+        Close = new TSeries(_t, _c) { Name = "Close" };
+        Volume = new TSeries(_t, _v) { Name = "Volume" };
+    }
+
+    public int Count
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _c.Count;
+    }
+
+    public TBar this[int index]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new(_t[index], _o[index], _h[index], _l[index], _c[index], _v[index]);
+    }
+
+    public TBar Last
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _c.Count > 0 ? new(_t[^1], _o[^1], _h[^1], _l[^1], _c[^1], _v[^1]) : default;
+    }
+
+    public long LastTime { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _t.Count > 0 ? _t[^1] : 0; }
+    public double LastOpen { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _o.Count > 0 ? _o[^1] : double.NaN; }
+    public double LastHigh { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _h.Count > 0 ? _h[^1] : double.NaN; }
+    public double LastLow { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _l.Count > 0 ? _l[^1] : double.NaN; }
+    public double LastClose { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _c.Count > 0 ? _c[^1] : double.NaN; }
+    public double LastVolume { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => _v.Count > 0 ? _v[^1] : double.NaN; }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(TBar bar, bool isNew = true)
+    {
+        if (isNew || _c.Count == 0)
+        {
+            _t.Add(bar.Time);
+            _o.Add(bar.Open);
+            _h.Add(bar.High);
+            _l.Add(bar.Low);
+            _c.Add(bar.Close);
+            _v.Add(bar.Volume);
+        }
+        else
+        {
+            int lastIdx = _c.Count - 1;
+            _t[lastIdx] = bar.Time;
+            _o[lastIdx] = bar.Open;
+            _h[lastIdx] = bar.High;
+            _l[lastIdx] = bar.Low;
+            _c[lastIdx] = bar.Close;
+            _v[lastIdx] = bar.Volume;
+        }
+
+        Pub?.Invoke(bar);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(long time, double open, double high, double low, double close, double volume, bool isNew = true) =>
+        Add(new TBar(time, open, high, low, close, volume), isNew);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(DateTime time, double open, double high, double low, double close, double volume, bool isNew = true) =>
+        Add(new TBar(time.Ticks, open, high, low, close, volume), isNew);
+
+    public void Add(IEnumerable<long> t, IEnumerable<double> o, IEnumerable<double> h, IEnumerable<double> l, IEnumerable<double> c, IEnumerable<double> v)
+    {
+        var tArr = t as long[] ?? t.ToArray();
+        var oArr = o as double[] ?? o.ToArray();
+        var hArr = h as double[] ?? h.ToArray();
+        var lArr = l as double[] ?? l.ToArray();
+        var cArr = c as double[] ?? c.ToArray();
+        var vArr = v as double[] ?? v.ToArray();
+
+        if (tArr.Length != oArr.Length || oArr.Length != hArr.Length ||
+            hArr.Length != lArr.Length || lArr.Length != cArr.Length ||
+            cArr.Length != vArr.Length)
+        {
+            throw new ArgumentException("All arrays must have the same length");
+        }
+
+        for (int i = 0; i < tArr.Length; i++)
+        {
+            Add(tArr[i], oArr[i], hArr[i], lArr[i], cArr[i], vArr[i]);
+        }
+    }
+
+    public IEnumerator<TBar> GetEnumerator()
+    {
+        for (int i = 0; i < _c.Count; i++)
+        {
+            yield return new TBar(_t[i], _o[i], _h[i], _l[i], _c[i], _v[i]);
+        }
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}

lib/core/tseries/tseries.cs

@@ -1,134 +1,134 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace QuanTAlib;
-
-/// <summary>
-/// A high-performance time series implementation using Structure of Arrays (SoA) layout.
-/// Stores Time (long) and Value (double) in separate contiguous arrays for SIMD efficiency.
-/// Supports "New Bar" vs "Update Last" streaming semantics.
-/// </summary>
-    public class TSeries : IReadOnlyList<TValue>, ITValuePublisher
-    {
-    protected readonly List<long> _t;
-    protected readonly List<double> _v;
-
-    public string Name { get; set; } = "Data";
-
-    public event Action<TValue>? Pub;
-
-    public TSeries() : this(0)
-    {
-    }
-
-    public TSeries(int capacity)
-    {
-        _t = new List<long>(capacity);
-        _v = new List<double>(capacity);
-    }
-
-    public TSeries(List<long> time, List<double> values)
-    {
-        _t = time;
-        _v = values;
-    }
-
-    public int Count
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => _v.Count;
-    }
-
-    public TValue this[int index]
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => new(_t[index], _v[index]);
-    }
-
-    public TValue Last
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => _v.Count > 0 ? new(_t[^1], _v[^1]) : default;
-    }
-
-    public double LastValue
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => _v.Count > 0 ? _v[^1] : double.NaN;
-    }
-
-    public long LastTime
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => _t.Count > 0 ? _t[^1] : 0;
-    }
-
-    /// <summary>
-    /// Direct access to the underlying Value array as a Span for SIMD operations.
-    /// </summary>
-    public ReadOnlySpan<double> Values
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => CollectionsMarshal.AsSpan(_v);
-    }
-
-    /// <summary>
-    /// Direct access to the underlying Time array as a Span.
-    /// </summary>
-    public ReadOnlySpan<long> Times
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => CollectionsMarshal.AsSpan(_t);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public virtual void Add(TValue value, bool isNew)
-    {
-        if (isNew || _v.Count == 0)
-        {
-            _t.Add(value.Time);
-            _v.Add(value.Value);
-        }
-        else
-        {
-            int lastIdx = _v.Count - 1;
-            _t[lastIdx] = value.Time;
-            _v[lastIdx] = value.Value;
-        }
-        Pub?.Invoke(value);
-    }
-
-    // Overload for backward compatibility (assumes isNew=true)
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public virtual void Add(TValue value) => Add(value, true);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(long time, double value, bool isNew = true) => Add(new TValue(time, value), isNew);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(DateTime time, double value, bool isNew = true) => Add(new TValue(time, value), isNew);
-
-    public void Add(IEnumerable<double> values)
-    {
-        long t = DateTime.UtcNow.Ticks;
-        foreach (var v in values)
-        {
-            Add(new TValue(t, v), isNew: true);
-            t += TimeSpan.TicksPerMinute;
-        }
-    }
-
-    // IEnumerable implementation
-    public IEnumerator<TValue> GetEnumerator()
-    {
-        for (int i = 0; i < _v.Count; i++)
-        {
-            yield return new TValue(_t[i], _v[i]);
-        }
-    }
-
-    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-}
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// A high-performance time series implementation using Structure of Arrays (SoA) layout.
+/// Stores Time (long) and Value (double) in separate contiguous arrays for SIMD efficiency.
+/// Supports "New Bar" vs "Update Last" streaming semantics.
+/// </summary>
+public class TSeries : IReadOnlyList<TValue>, ITValuePublisher
+{
+    protected readonly List<long> _t;
+    protected readonly List<double> _v;
+
+    public string Name { get; set; } = "Data";
+
+    public event Action<TValue>? Pub;
+
+    public TSeries() : this(0)
+    {
+    }
+
+    public TSeries(int capacity)
+    {
+        _t = new List<long>(capacity);
+        _v = new List<double>(capacity);
+    }
+
+    public TSeries(List<long> time, List<double> values)
+    {
+        _t = time;
+        _v = values;
+    }
+
+    public int Count
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _v.Count;
+    }
+
+    public TValue this[int index]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new(_t[index], _v[index]);
+    }
+
+    public TValue Last
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _v.Count > 0 ? new(_t[^1], _v[^1]) : default;
+    }
+
+    public double LastValue
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _v.Count > 0 ? _v[^1] : double.NaN;
+    }
+
+    public long LastTime
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _t.Count > 0 ? _t[^1] : 0;
+    }
+
+    /// <summary>
+    /// Direct access to the underlying Value array as a Span for SIMD operations.
+    /// </summary>
+    public ReadOnlySpan<double> Values
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => CollectionsMarshal.AsSpan(_v);
+    }
+
+    /// <summary>
+    /// Direct access to the underlying Time array as a Span.
+    /// </summary>
+    public ReadOnlySpan<long> Times
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => CollectionsMarshal.AsSpan(_t);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public virtual void Add(TValue value, bool isNew)
+    {
+        if (isNew || _v.Count == 0)
+        {
+            _t.Add(value.Time);
+            _v.Add(value.Value);
+        }
+        else
+        {
+            int lastIdx = _v.Count - 1;
+            _t[lastIdx] = value.Time;
+            _v[lastIdx] = value.Value;
+        }
+        Pub?.Invoke(value);
+    }
+
+    // Overload for backward compatibility (assumes isNew=true)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public virtual void Add(TValue value) => Add(value, true);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(long time, double value, bool isNew = true) => Add(new TValue(time, value), isNew);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(DateTime time, double value, bool isNew = true) => Add(new TValue(time, value), isNew);
+
+    public void Add(IEnumerable<double> values)
+    {
+        long t = DateTime.UtcNow.Ticks;
+        foreach (var v in values)
+        {
+            Add(new TValue(t, v), isNew: true);
+            t += TimeSpan.TicksPerMinute;
+        }
+    }
+
+    // IEnumerable implementation
+    public IEnumerator<TValue> GetEnumerator()
+    {
+        for (int i = 0; i < _v.Count; i++)
+        {
+            yield return new TValue(_t[i], _v[i]);
+        }
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}

lib/core/tvalue/tvalue.cs

@@ -1,47 +1,47 @@
-using System.Runtime.CompilerServices;
-
-namespace QuanTAlib;
-
-/// <summary>
-/// A lightweight struct representing a time-value pair.
-/// Pure data type: 16 bytes (long + double).
-/// </summary>
-[SkipLocalsInit]
-public readonly struct TValue : IEquatable<TValue>
-{
-    public readonly long Time;
-    public readonly double Value;
-
-    public DateTime AsDateTime => new(Time, DateTimeKind.Utc);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public TValue(long time, double value)
-    {
-        Time = time;
-        Value = value;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public TValue(DateTime time, double value)
-    {
-        Time = time.Kind == DateTimeKind.Utc ? time.Ticks : time.ToUniversalTime().Ticks;
-        Value = value;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator double(TValue tv) => tv.Value;
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator DateTime(TValue tv) => new(tv.Time, DateTimeKind.Utc);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public override string ToString() => $"[{AsDateTime:yyyy-MM-dd HH:mm:ss}, {Value:F2}]";
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool Equals(TValue other) => Time == other.Time && Value == other.Value;
-
-    public override bool Equals(object? obj) => obj is TValue other && Equals(other);
-    public override int GetHashCode() => HashCode.Combine(Time, Value);
-    public static bool operator ==(TValue left, TValue right) => left.Equals(right);
-    public static bool operator !=(TValue left, TValue right) => !left.Equals(right);
-}
+using System.Runtime.CompilerServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// A lightweight struct representing a time-value pair.
+/// Pure data type: 16 bytes (long + double).
+/// </summary>
+[SkipLocalsInit]
+public readonly struct TValue : IEquatable<TValue>
+{
+    public readonly long Time;
+    public readonly double Value;
+
+    public DateTime AsDateTime => new(Time, DateTimeKind.Utc);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TValue(long time, double value)
+    {
+        Time = time;
+        Value = value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TValue(DateTime time, double value)
+    {
+        Time = time.Kind == DateTimeKind.Utc ? time.Ticks : time.ToUniversalTime().Ticks;
+        Value = value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator double(TValue tv) => tv.Value;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator DateTime(TValue tv) => new(tv.Time, DateTimeKind.Utc);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override string ToString() => $"[{AsDateTime:yyyy-MM-dd HH:mm:ss}, {Value:F2}]";
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Equals(TValue other) => Time == other.Time && Value == other.Value;
+
+    public override bool Equals(object? obj) => obj is TValue other && Equals(other);
+    public override int GetHashCode() => HashCode.Combine(Time, Value);
+    public static bool operator ==(TValue left, TValue right) => left.Equals(right);
+    public static bool operator !=(TValue left, TValue right) => !left.Equals(right);
+}