Remove multiple Pine Script indicators: SSFDSP, STARCHANNEL, STBANDS, STC, UBANDS, UCHANNEL, VWAPBANDS, and VWAPSD. These indicators were deleted to streamline the library and remove unused or redundant code.

2026-08-17 10:08:05 +00:00 · 2026-02-20 18:44:56 -08:00
parent 3dd05f23e4
commit cbeefc9d64
283 changed files with 23963 additions and 3838 deletions
@@ -0,0 +1,892 @@
+
+#pragma warning disable CS0618 // Tests intentionally use obsolete Next(bool) overload to verify it still works
+
+namespace QuanTAlib.Tests;
+
+public sealed class CsvFeedTests : IDisposable
+{
+    private const string TestCsvPath = "daily_IBM.csv";
+    private readonly List<string> _tempFiles = new();
+    private bool _disposed;
+
+    // Static test data arrays to avoid CA1861 (constant arrays as arguments)
+    private static readonly string[] HeaderOnlyData = ["timestamp,open,high,low,close,volume"];
+    private static readonly string[] MalformedDateData = ["timestamp,open,high,low,close,volume", "not-a-date,100,101,99,100,1000"];
+    private static readonly string[] MalformedPriceData = ["timestamp,open,high,low,close,volume", "2023-01-01,not-a-number,101,99,100,1000"];
+    private static readonly string[] MissingColumnsData = ["timestamp,open,high,low,close,volume", "2023-01-01,100,101,99,100"];
+    private static readonly string[] ExtraColumnsData = ["timestamp,open,high,low,close,volume,extra", "2023-01-01,100,101,99,100,1000,extra_data"];
+    private static readonly string[] SingleBarData = ["timestamp,open,high,low,close,volume", "2023-01-01,100,101,99,100,1000"];
+    private static readonly string[] DecimalPrecisionData = ["timestamp,open,high,low,close,volume", "2023-01-01,100.1234,101.5678,99.9999,100.0001,1234567.89"];
+    private static readonly string[] NegativeValuesData = ["timestamp,open,high,low,close,volume", "2023-01-01,-100,50,-150,-50,1000"];
+    private static readonly string[] ScientificNotationData = ["timestamp,open,high,low,close,volume", "2023-01-01,1.5e2,2e2,1e2,1.75e2,1e6"];
+    private static readonly string[] GapDataReversed = ["timestamp,open,high,low,close,volume", "2023-01-05,103,104,102,103,1000", "2023-01-04,102,103,101,102,1000", "2023-01-02,101,102,100,101,1000", "2023-01-01,100,101,99,100,1000"];
+    private static readonly string[] WhitespaceData = ["timestamp,open,high,low,close,volume", "  2023-01-01  ,  100  ,  101  ,  99  ,  100  ,  1000  "];
+    private static readonly string[] ZeroValuesData = ["timestamp,open,high,low,close,volume", "2023-01-01,0,0,0,0,0"];
+    private static readonly string[] LargeValuesData = ["timestamp,open,high,low,close,volume", "2023-01-01,999999999.99,1000000000.01,999999999.00,999999999.50,9999999999999"];
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+
+        foreach (var file in _tempFiles)
+        {
+            if (File.Exists(file))
+            {
+                try { File.Delete(file); } catch { /* ignore */ }
+            }
+        }
+    }
+
+    private string CreateTempCsv(string[] lines)
+    {
+        string tempPath = Path.GetTempFileName() + ".csv";
+        File.WriteAllLines(tempPath, lines);
+        _tempFiles.Add(tempPath);
+        return tempPath;
+    }
+
+    #region Constructor Tests
+
+    [Fact]
+    public void Constructor_ValidFile_LoadsData()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        Assert.NotNull(feed);
+        Assert.True(feed.Count > 0);
+    }
+
+    [Fact]
+    public void Constructor_NonExistentFile_ThrowsFileNotFoundException()
+    {
+        Assert.Throws<FileNotFoundException>(() => new CsvFeed("nonexistent.csv"));
+    }
+
+    [Fact]
+    public void Constructor_NullPath_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new CsvFeed(null!));
+        Assert.Equal("filePath", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_EmptyPath_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new CsvFeed(""));
+        Assert.Equal("filePath", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_WhitespacePath_ThrowsArgumentException()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => new CsvFeed("   "));
+        Assert.Equal("filePath", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_EmptyCsv_ThrowsInvalidDataException()
+    {
+        string tempCsv = CreateTempCsv(Array.Empty<string>());
+        Assert.Throws<InvalidDataException>(() => new CsvFeed(tempCsv));
+    }
+
+    [Fact]
+    public void Constructor_HeaderOnlyCsv_ThrowsInvalidDataException()
+    {
+        string tempCsv = CreateTempCsv(HeaderOnlyData);
+        Assert.Throws<InvalidDataException>(() => new CsvFeed(tempCsv));
+    }
+
+    [Fact]
+    public void Constructor_MalformedDate_ThrowsFormatException()
+    {
+        string tempCsv = CreateTempCsv(MalformedDateData);
+        Assert.Throws<FormatException>(() => new CsvFeed(tempCsv));
+    }
+
+    [Fact]
+    public void Constructor_MalformedPrice_ThrowsFormatException()
+    {
+        string tempCsv = CreateTempCsv(MalformedPriceData);
+        Assert.Throws<FormatException>(() => new CsvFeed(tempCsv));
+    }
+
+    [Fact]
+    public void Constructor_MissingColumns_ThrowsFormatException()
+    {
+        string tempCsv = CreateTempCsv(MissingColumnsData);
+        Assert.Throws<FormatException>(() => new CsvFeed(tempCsv));
+    }
+
+    [Fact]
+    public void Constructor_ExtraColumns_ThrowsFormatException()
+    {
+        // Extra columns should throw format exception (strict 6-column format)
+        string tempCsv = CreateTempCsv(ExtraColumnsData);
+        Assert.Throws<FormatException>(() => new CsvFeed(tempCsv));
+    }
+
+    #endregion
+
+    #region Property Tests
+
+    [Fact]
+    public void Count_ReturnsCorrectNumber()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        Assert.True(feed.Count > 0);
+        // IBM CSV has 100 rows of data
+        Assert.Equal(100, feed.Count);
+    }
+
+    [Fact]
+    public void FilePath_ReturnsLoadedPath()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        Assert.Equal(TestCsvPath, feed.FilePath);
+    }
+
+    [Fact]
+    public void HasMore_TrueAtStart()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        Assert.True(feed.HasMore);
+    }
+
+    [Fact]
+    public void HasMore_FalseWhenExhausted()
+    {
+        string tempCsv = CreateTempCsv(SingleBarData);
+        var feed = new CsvFeed(tempCsv);
+
+        Assert.True(feed.HasMore);
+        feed.Next(isNew: true);
+        Assert.False(feed.HasMore);
+    }
+
+    [Fact]
+    public void CurrentIndex_StartsAtZero()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        Assert.Equal(0, feed.CurrentIndex);
+    }
+
+    [Fact]
+    public void CurrentIndex_IncrementsOnNext()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        Assert.Equal(0, feed.CurrentIndex);
+        feed.Next(isNew: true);
+        Assert.Equal(1, feed.CurrentIndex);
+        feed.Next(isNew: true);
+        Assert.Equal(2, feed.CurrentIndex);
+    }
+
+    [Fact]
+    public void CurrentIndex_DoesNotIncrementOnUpdate()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        feed.Next(isNew: true);
+        int indexAfterFirst = feed.CurrentIndex;
+
+        feed.Next(isNew: false);
+        Assert.Equal(indexAfterFirst, feed.CurrentIndex);
+    }
+
+    [Fact]
+    public void HasCurrentBar_FalseAtStart()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        Assert.False(feed.HasCurrentBar);
+    }
+
+    [Fact]
+    public void HasCurrentBar_TrueAfterNext()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        feed.Next(isNew: true);
+        Assert.True(feed.HasCurrentBar);
+    }
+
+    [Fact]
+    public void Data_ReturnsUnderlyingSeries()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        var data = feed.Data;
+
+        Assert.NotNull(data);
+        Assert.Equal(feed.Count, data.Count);
+    }
+
+    #endregion
+
+    #region Next Method Tests
+
+    [Fact]
+    public void Next_StreamsDataChronologically()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Get first bar
+        var bar1 = feed.Next(isNew: true);
+        Assert.True(bar1.Time > 0);
+
+        // Get second bar - should be later in time
+        var bar2 = feed.Next(isNew: true);
+        Assert.True(bar2.Time > bar1.Time);
+
+        // Get third bar
+        var bar3 = feed.Next(isNew: true);
+        Assert.True(bar3.Time > bar2.Time);
+    }
+
+    [Fact]
+    public void Next_WithRefParameter_StreamsCorrectly()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        bool isNew = true;
+        var bar1 = feed.Next(ref isNew);
+        Assert.True(isNew); // Should still be true
+        Assert.True(bar1.Time > 0);
+
+        isNew = true;
+        var bar2 = feed.Next(ref isNew);
+        Assert.True(isNew);
+        Assert.True(bar2.Time > bar1.Time);
+    }
+
+    [Fact]
+    public void Next_UpdateCurrentBar_ReturnsSameBar()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Get first bar
+        var bar1 = feed.Next(isNew: true);
+
+        // Update current bar (should return same bar)
+        var bar2 = feed.Next(isNew: false);
+        Assert.Equal(bar1.Time, bar2.Time);
+        Assert.Equal(bar1.Close, bar2.Close);
+
+        // Get next bar
+        var bar3 = feed.Next(isNew: true);
+        Assert.True(bar3.Time > bar1.Time);
+    }
+
+    [Fact]
+    public void Next_EndOfData_SignalsNoMoreData()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Stream through all data
+        TBar lastBar = default;
+        bool isNew = true;
+        int count = 0;
+
+        while (isNew && count < 200) // Safety limit
+        {
+            lastBar = feed.Next(ref isNew);
+            count++;
+        }
+
+        // Should have reached end and isNew should be false
+        Assert.False(isNew);
+        Assert.True(lastBar.Time > 0);
+
+        // Calling again should return same bar with isNew=false
+        isNew = true;
+        var finalBar = feed.Next(ref isNew);
+        Assert.False(isNew);
+        Assert.Equal(lastBar.Time, finalBar.Time);
+    }
+
+    [Fact]
+    public void Next_EmptyData_ReturnsDefaultAndSignalsNoMore()
+    {
+        // Create a mock scenario - but since constructor throws on empty,
+        // we test the behavior when all data is consumed
+        string tempCsv = CreateTempCsv(SingleBarData);
+        var feed = new CsvFeed(tempCsv);
+
+        // Consume all data
+        bool isNew = true;
+        feed.Next(ref isNew);
+
+        // Now at end
+        isNew = true;
+        var bar = feed.Next(ref isNew);
+        Assert.False(isNew);
+        Assert.Equal(100.0, bar.Close); // Returns last bar
+    }
+
+    [Fact]
+    public void Next_DefaultParameter_IsNewTrue()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        var bar1 = feed.Next(); // Default isNew = true
+        var bar2 = feed.Next(); // Default isNew = true
+        Assert.True(bar2.Time > bar1.Time);
+    }
+
+    #endregion
+
+    #region Fetch Method Tests
+
+    [Fact]
+    public void Fetch_ReturnsCorrectNumberOfBars()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        var startTime = new DateTime(2025, 7, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        var interval = TimeSpan.FromDays(1);
+
+        var series = feed.Fetch(10, startTime, interval);
+
+        Assert.True(series.Count > 0);
+        Assert.True(series.Count <= 10);
+    }
+
+    [Fact]
+    public void Fetch_ZeroCount_ThrowsArgumentException()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        var startTime = DateTime.UtcNow.Ticks;
+        var interval = TimeSpan.FromDays(1);
+
+        var ex = Assert.Throws<ArgumentException>(() => feed.Fetch(0, startTime, interval));
+        Assert.Equal("count", ex.ParamName);
+    }
+
+    [Fact]
+    public void Fetch_NegativeCount_ThrowsArgumentException()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        var startTime = DateTime.UtcNow.Ticks;
+        var interval = TimeSpan.FromDays(1);
+
+        var ex = Assert.Throws<ArgumentException>(() => feed.Fetch(-1, startTime, interval));
+        Assert.Equal("count", ex.ParamName);
+    }
+
+    [Fact]
+    public void Fetch_ResetsStreamingPosition()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Stream a few bars
+        feed.Next(isNew: true);
+        feed.Next(isNew: true);
+        feed.Next(isNew: true);
+
+        // Fetch from start
+        var startTime = new DateTime(2025, 7, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        feed.Fetch(5, startTime, TimeSpan.FromDays(1));
+
+        // Next should now stream from fetched position
+        var bar = feed.Next(isNew: true);
+        Assert.True(bar.Time >= startTime);
+    }
+
+    [Fact]
+    public void Fetch_ResetsHasCurrentBar()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        feed.Next(isNew: true);
+        Assert.True(feed.HasCurrentBar);
+
+        var startTime = new DateTime(2025, 7, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        feed.Fetch(5, startTime, TimeSpan.FromDays(1));
+
+        Assert.False(feed.HasCurrentBar);
+    }
+
+    #endregion
+
+    #region Reset Method Tests
+
+    [Fact]
+    public void Reset_ReturnsToStart()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Advance several bars
+        var firstBar = feed.Next(isNew: true);
+        feed.Next(isNew: true);
+        feed.Next(isNew: true);
+        Assert.Equal(3, feed.CurrentIndex);
+
+        // Reset
+        feed.Reset();
+
+        Assert.Equal(0, feed.CurrentIndex);
+        Assert.True(feed.HasMore);
+        Assert.False(feed.HasCurrentBar);
+
+        // Next bar should be first bar again
+        var afterReset = feed.Next(isNew: true);
+        Assert.Equal(firstBar.Time, afterReset.Time);
+        Assert.Equal(firstBar.Close, afterReset.Close);
+    }
+
+    [Fact]
+    public void Reset_WithIndex_SetsCorrectPosition()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Reset to middle
+        const int targetIndex = 50;
+        feed.Reset(targetIndex);
+
+        Assert.Equal(targetIndex, feed.CurrentIndex);
+        Assert.False(feed.HasCurrentBar);
+
+        // Next bar should be at that index
+        var bar = feed.Next(isNew: true);
+        var expectedBar = feed.GetBar(targetIndex);
+        Assert.Equal(expectedBar.Time, bar.Time);
+    }
+
+    [Fact]
+    public void Reset_WithNegativeIndex_ThrowsArgumentOutOfRangeException()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => feed.Reset(-1));
+        Assert.Equal("index", ex.ParamName);
+    }
+
+    [Fact]
+    public void Reset_WithIndexBeyondCount_ThrowsArgumentOutOfRangeException()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => feed.Reset(feed.Count + 1));
+        Assert.Equal("index", ex.ParamName);
+    }
+
+    [Fact]
+    public void Reset_WithIndexAtCount_IsValid()
+    {
+        // Resetting to exactly Count means "at end" - valid but no more data
+        var feed = new CsvFeed(TestCsvPath);
+        feed.Reset(feed.Count);
+
+        Assert.Equal(feed.Count, feed.CurrentIndex);
+        Assert.False(feed.HasMore);
+    }
+
+    #endregion
+
+    #region GetBar Method Tests
+
+    [Fact]
+    public void GetBar_ReturnsCorrectBar()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Get bar without affecting streaming
+        var bar0 = feed.GetBar(0);
+        var bar1 = feed.GetBar(1);
+
+        // Streaming position unchanged
+        Assert.Equal(0, feed.CurrentIndex);
+
+        // Bars should be in chronological order
+        Assert.True(bar1.Time > bar0.Time);
+    }
+
+    [Fact]
+    public void GetBar_NegativeIndex_ThrowsArgumentOutOfRangeException()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => feed.GetBar(-1));
+        Assert.Equal("index", ex.ParamName);
+    }
+
+    [Fact]
+    public void GetBar_IndexAtCount_ThrowsArgumentOutOfRangeException()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => feed.GetBar(feed.Count));
+        Assert.Equal("index", ex.ParamName);
+    }
+
+    [Fact]
+    public void GetBar_DoesNotAffectStreaming()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Stream first bar
+        var streamed = feed.Next(isNew: true);
+        int indexAfter = feed.CurrentIndex;
+
+        // Random access
+        var bar50 = feed.GetBar(50);
+        Assert.True(bar50.Time > 0);
+
+        // Streaming position unchanged
+        Assert.Equal(indexAfter, feed.CurrentIndex);
+
+        // Continue streaming
+        var next = feed.Next(isNew: true);
+        Assert.True(next.Time > streamed.Time);
+    }
+
+    [Fact]
+    public void GetBar_ConsistentWithNext()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Get bars via random access
+        var bar0 = feed.GetBar(0);
+        var bar1 = feed.GetBar(1);
+        var bar2 = feed.GetBar(2);
+
+        // Get same bars via streaming
+        var streamed0 = feed.Next(isNew: true);
+        var streamed1 = feed.Next(isNew: true);
+        var streamed2 = feed.Next(isNew: true);
+
+        Assert.Equal(bar0.Time, streamed0.Time);
+        Assert.Equal(bar1.Time, streamed1.Time);
+        Assert.Equal(bar2.Time, streamed2.Time);
+    }
+
+    #endregion
+
+    #region OHLCV Validation Tests
+
+    [Fact]
+    public void LoadFromCsv_ParsesValuesCorrectly()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Get first bar (oldest in chronological order)
+        var bar = feed.Next(isNew: true);
+
+        // Verify it has valid OHLCV data
+        Assert.True(bar.Open > 0);
+        Assert.True(bar.High >= bar.Open);
+        Assert.True(bar.High >= bar.Close);
+        Assert.True(bar.Low <= bar.Open);
+        Assert.True(bar.Low <= bar.Close);
+        Assert.True(bar.Close > 0);
+        Assert.True(bar.Volume > 0);
+    }
+
+    [Fact]
+    public void LoadFromCsv_DataInChronologicalOrder()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        var bars = new List<TBar>();
+        bool isNew = true;
+
+        // Collect first 10 bars
+        for (int i = 0; i < 10 && isNew; i++)
+        {
+            bars.Add(feed.Next(ref isNew));
+        }
+
+        // Verify chronological order (each bar later than previous)
+        for (int i = 1; i < bars.Count; i++)
+        {
+            Assert.True(bars[i].Time > bars[i - 1].Time,
+                $"Bar {i} time ({bars[i].AsDateTime}) should be after bar {i - 1} time ({bars[i - 1].AsDateTime})");
+        }
+    }
+
+    [Fact]
+    public void LoadFromCsv_AllBarsHaveValidOHLCV()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        for (int i = 0; i < feed.Count; i++)
+        {
+            var bar = feed.GetBar(i);
+
+            Assert.True(double.IsFinite(bar.Open), $"Bar {i} has non-finite Open");
+            Assert.True(double.IsFinite(bar.High), $"Bar {i} has non-finite High");
+            Assert.True(double.IsFinite(bar.Low), $"Bar {i} has non-finite Low");
+            Assert.True(double.IsFinite(bar.Close), $"Bar {i} has non-finite Close");
+            Assert.True(double.IsFinite(bar.Volume), $"Bar {i} has non-finite Volume");
+
+            Assert.True(bar.High >= bar.Low, $"Bar {i}: High ({bar.High}) < Low ({bar.Low})");
+            Assert.True(bar.High >= bar.Open, $"Bar {i}: High ({bar.High}) < Open ({bar.Open})");
+            Assert.True(bar.High >= bar.Close, $"Bar {i}: High ({bar.High}) < Close ({bar.Close})");
+            Assert.True(bar.Low <= bar.Open, $"Bar {i}: Low ({bar.Low}) > Open ({bar.Open})");
+            Assert.True(bar.Low <= bar.Close, $"Bar {i}: Low ({bar.Low}) > Close ({bar.Close})");
+        }
+    }
+
+    [Fact]
+    public void LoadFromCsv_ParsesDecimalsCorrectly()
+    {
+        string tempCsv = CreateTempCsv(DecimalPrecisionData);
+        var feed = new CsvFeed(tempCsv);
+        var bar = feed.Next(isNew: true);
+
+        Assert.Equal(100.1234, bar.Open, precision: 4);
+        Assert.Equal(101.5678, bar.High, precision: 4);
+        Assert.Equal(99.9999, bar.Low, precision: 4);
+        Assert.Equal(100.0001, bar.Close, precision: 4);
+        Assert.Equal(1234567.89, bar.Volume, precision: 2);
+    }
+
+    [Fact]
+    public void LoadFromCsv_ParsesNegativeValues()
+    {
+        // While negative prices are unusual, the parser should handle them
+        string tempCsv = CreateTempCsv(NegativeValuesData);
+        var feed = new CsvFeed(tempCsv);
+        var bar = feed.Next(isNew: true);
+
+        Assert.Equal(-100, bar.Open);
+        Assert.Equal(50, bar.High);
+        Assert.Equal(-150, bar.Low);
+        Assert.Equal(-50, bar.Close);
+    }
+
+    [Fact]
+    public void LoadFromCsv_ParsesScientificNotation()
+    {
+        string tempCsv = CreateTempCsv(ScientificNotationData);
+        var feed = new CsvFeed(tempCsv);
+        var bar = feed.Next(isNew: true);
+
+        Assert.Equal(150, bar.Open);
+        Assert.Equal(200, bar.High);
+        Assert.Equal(100, bar.Low);
+        Assert.Equal(175, bar.Close);
+        Assert.Equal(1000000, bar.Volume);
+    }
+
+    #endregion
+
+    #region IFeed Interface Tests
+
+    [Fact]
+    public void CsvFeed_WorksWithIFeedInterface()
+    {
+        CsvFeed feed = new CsvFeed(TestCsvPath);
+
+        var bar1 = feed.Next(isNew: true);
+        Assert.True(bar1.Time > 0);
+
+        var bar2 = feed.Next(isNew: true);
+        Assert.True(bar2.Time > bar1.Time);
+    }
+
+    [Fact]
+    public void CsvFeed_IFeedRefOverload()
+    {
+        CsvFeed feed = new CsvFeed(TestCsvPath);
+
+        bool isNew = true;
+        var bar1 = feed.Next(ref isNew);
+        Assert.True(bar1.Time > 0);
+
+        isNew = false;
+        var bar1Update = feed.Next(ref isNew);
+        Assert.Equal(bar1.Time, bar1Update.Time);
+    }
+
+    [Fact]
+    public void CsvFeed_IFeedFetch()
+    {
+        CsvFeed feed = new CsvFeed(TestCsvPath);
+
+        var startTime = new DateTime(2025, 7, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        var series = feed.Fetch(5, startTime, TimeSpan.FromDays(1));
+
+        Assert.True(series.Count > 0);
+    }
+
+    #endregion
+
+    #region Edge Case Tests
+
+    [Fact]
+    public void Next_MixedNewAndUpdate_WorksCorrectly()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        var bar1 = feed.Next(isNew: true);
+        var bar1Update = feed.Next(isNew: false);
+        Assert.Equal(bar1.Time, bar1Update.Time);
+
+        var bar2 = feed.Next(isNew: true);
+        Assert.True(bar2.Time > bar1.Time);
+
+        var bar2Update = feed.Next(isNew: false);
+        Assert.Equal(bar2.Time, bar2Update.Time);
+
+        var bar3 = feed.Next(isNew: true);
+        Assert.True(bar3.Time > bar2.Time);
+    }
+
+    [Fact]
+    public void Fetch_WithEarlyStartTime_ReturnsData()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Start from very early date (before any data)
+        var startTime = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        var series = feed.Fetch(5, startTime, TimeSpan.FromDays(1));
+
+        // Should return data starting from first available bar
+        Assert.True(series.Count > 0);
+    }
+
+    [Fact]
+    public void Fetch_WithFutureStartTime_ReturnsEmpty()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // Start from future date (after all data)
+        var startTime = new DateTime(2030, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        var series = feed.Fetch(5, startTime, TimeSpan.FromDays(1));
+
+        // Should return empty or minimal data
+        Assert.Empty(series);
+    }
+
+    [Fact]
+    public void Fetch_HandlesGapsCorrectly()
+    {
+        // Create CSV with gaps using helper
+        string tempCsv = CreateTempCsv(GapDataReversed);
+
+        var feed = new CsvFeed(tempCsv);
+        var startTime = new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        var interval = TimeSpan.FromDays(1);
+
+        // Fetch bars. Should get 4 bars (Jan 1, 2, 4, 5).
+        var series = feed.Fetch(10, startTime, interval);
+
+        Assert.Equal(4, series.Count);
+        Assert.Equal(startTime, series[0].Time); // Jan 1
+        Assert.Equal(startTime + interval.Ticks, series[1].Time); // Jan 2
+        // Gap here (Jan 3 missing)
+        Assert.Equal(startTime + 3 * interval.Ticks, series[2].Time); // Jan 4
+        Assert.Equal(startTime + 4 * interval.Ticks, series[3].Time); // Jan 5
+    }
+
+    [Fact]
+    public void SingleBar_StreamsAndEnds()
+    {
+        string tempCsv = CreateTempCsv(SingleBarData);
+        var feed = new CsvFeed(tempCsv);
+
+        Assert.Equal(1, feed.Count);
+        Assert.True(feed.HasMore);
+
+        bool isNew = true;
+        var bar = feed.Next(ref isNew);
+        Assert.True(isNew);
+        Assert.Equal(100.0, bar.Close);
+        Assert.False(feed.HasMore);
+
+        // Try to get next
+        isNew = true;
+        var noMore = feed.Next(ref isNew);
+        Assert.False(isNew); // Signals end
+        Assert.Equal(bar.Time, noMore.Time); // Returns last bar
+    }
+
+    [Fact]
+    public void WhitespaceInValues_Trimmed()
+    {
+        string tempCsv = CreateTempCsv(WhitespaceData);
+        var feed = new CsvFeed(tempCsv);
+        var bar = feed.Next(isNew: true);
+
+        Assert.Equal(100.0, bar.Open);
+        Assert.Equal(101.0, bar.High);
+        Assert.Equal(99.0, bar.Low);
+        Assert.Equal(100.0, bar.Close);
+        Assert.Equal(1000.0, bar.Volume);
+    }
+
+    [Fact]
+    public void ZeroValues_Accepted()
+    {
+        string tempCsv = CreateTempCsv(ZeroValuesData);
+        var feed = new CsvFeed(tempCsv);
+        var bar = feed.Next(isNew: true);
+
+        Assert.Equal(0.0, bar.Open);
+        Assert.Equal(0.0, bar.High);
+        Assert.Equal(0.0, bar.Low);
+        Assert.Equal(0.0, bar.Close);
+        Assert.Equal(0.0, bar.Volume);
+    }
+
+    [Fact]
+    public void VeryLargeValues_Parsed()
+    {
+        string tempCsv = CreateTempCsv(LargeValuesData);
+        var feed = new CsvFeed(tempCsv);
+        var bar = feed.Next(isNew: true);
+
+        Assert.Equal(999999999.99, bar.Open, precision: 2);
+        Assert.Equal(1000000000.01, bar.High, precision: 2);
+        Assert.Equal(999999999.00, bar.Low, precision: 2);
+        Assert.Equal(999999999.50, bar.Close, precision: 2);
+        Assert.Equal(9999999999999.0, bar.Volume, precision: 0);
+    }
+
+    [Fact]
+    public void ConsecutiveResets_WorkCorrectly()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        feed.Next(isNew: true);
+        feed.Next(isNew: true);
+        feed.Reset();
+        feed.Reset();
+        feed.Reset();
+
+        Assert.Equal(0, feed.CurrentIndex);
+        Assert.False(feed.HasCurrentBar);
+    }
+
+    [Fact]
+    public void StreamThenResetThenStream_Consistent()
+    {
+        var feed = new CsvFeed(TestCsvPath);
+
+        // First pass
+        var firstPass = new List<double>();
+        for (int i = 0; i < 10; i++)
+        {
+            firstPass.Add(feed.Next(isNew: true).Close);
+        }
+
+        // Reset
+        feed.Reset();
+
+        // Second pass
+        var secondPass = new List<double>();
+        for (int i = 0; i < 10; i++)
+        {
+            secondPass.Add(feed.Next(isNew: true).Close);
+        }
+
+        // Should be identical
+        for (int i = 0; i < 10; i++)
+        {
+            Assert.Equal(firstPass[i], secondPass[i]);
+        }
+    }
+
+    #endregion
+}
@@ -0,0 +1,458 @@
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// Parsed OHLCV data from a CSV line.
+/// </summary>
+[StructLayout(LayoutKind.Auto)]
+internal readonly record struct ParsedOhlcv(long Time, double Open, double High, double Low, double Close, double Volume);
+
+/// <summary>
+/// Mutable state for parsing OHLCV columns. Used as ref parameter to reduce method signature size.
+/// </summary>
+[StructLayout(LayoutKind.Auto)]
+internal ref struct OhlcvParseState
+{
+    public long Time;
+    public double Open;
+    public double High;
+    public double Low;
+    public double Close;
+    public double Volume;
+}
+
+/// <summary>
+/// CSV file feed for loading historical OHLCV data.
+/// Loads data in constructor and streams through it with Next() or returns batches with Fetch().
+/// CSV format: timestamp,open,high,low,close,volume (header required)
+/// Timestamp format: YYYY-MM-DD (UTC midnight assumed)
+/// </summary>
+[SkipLocalsInit]
+public sealed class CsvFeed : IFeed
+{
+    private int _currentIndex;
+    private TBar _currentBar;
+    private bool _hasCurrentBar;
+
+    /// <summary>
+    /// Gets the total number of bars available in the CSV file.
+    /// </summary>
+    public int Count { get; }
+
+    /// <summary>
+    /// Gets the file path of the loaded CSV.
+    /// </summary>
+    public string FilePath { get; }
+
+    /// <summary>
+    /// Gets whether there are more bars to stream.
+    /// </summary>
+    public bool HasMore => _currentIndex < Count;
+
+    /// <summary>
+    /// Gets the current streaming position (0-based index).
+    /// </summary>
+    public int CurrentIndex => _currentIndex;
+
+    /// <summary>
+    /// Gets whether the feed has a current bar in progress.
+    /// </summary>
+    public bool HasCurrentBar => _hasCurrentBar;
+
+    /// <summary>
+    /// Loads CSV file and prepares data for streaming.
+    /// Data is reversed to chronological order (oldest first).
+    /// </summary>
+    /// <param name="filePath">Path to CSV file</param>
+    /// <exception cref="ArgumentException">Thrown when filePath is null or empty</exception>
+    /// <exception cref="FileNotFoundException">Thrown when the specified file does not exist</exception>
+    /// <exception cref="InvalidDataException">Thrown when CSV file is empty or contains only header</exception>
+    /// <exception cref="FormatException">Thrown when CSV format is invalid</exception>
+    public CsvFeed(string filePath)
+    {
+        if (string.IsNullOrWhiteSpace(filePath))
+        {
+            throw new ArgumentException("File path cannot be null or empty", nameof(filePath));
+        }
+
+        if (!File.Exists(filePath))
+        {
+            throw new FileNotFoundException($"CSV file not found: {filePath}", filePath);
+        }
+
+        FilePath = filePath;
+        Data = LoadFromCsv(filePath);
+        Count = Data.Count;
+        _currentIndex = 0;
+    }
+
+    /// <summary>
+    /// Parses CSV file into TBarSeries.
+    /// Expected format: timestamp,open,high,low,close,volume
+    /// Memory-efficient: reads lines into list, reverses in-place (no LINQ allocations).
+    /// </summary>
+    private static TBarSeries LoadFromCsv(string filePath)
+    {
+        var dataLines = new List<string>();
+        using (var reader = new StreamReader(filePath))
+        {
+            var header = reader.ReadLine();
+            if (header is null)
+            {
+                throw new InvalidDataException("CSV file is empty");
+            }
+
+            while (!reader.EndOfStream)
+            {
+                var line = reader.ReadLine();
+                if (!string.IsNullOrWhiteSpace(line))
+                {
+                    dataLines.Add(line);
+                }
+            }
+        }
+
+        if (dataLines.Count == 0)
+        {
+            throw new InvalidDataException("CSV file contains only header, no data");
+        }
+
+        // Reverse in-place to chronological order (oldest first)
+        dataLines.Reverse();
+
+        var series = new TBarSeries(dataLines.Count);
+
+        // Pre-allocate arrays for bulk loading (SoA layout)
+        long[] t = new long[dataLines.Count];
+        double[] o = new double[dataLines.Count];
+        double[] h = new double[dataLines.Count];
+        double[] l = new double[dataLines.Count];
+        double[] c = new double[dataLines.Count];
+        double[] v = new double[dataLines.Count];
+
+        for (int i = 0; i < dataLines.Count; i++)
+        {
+            var line = dataLines[i];
+            // After Reverse(), index i corresponds to original index (dataLines.Count - 1 - i)
+            int originalIndex = dataLines.Count - 1 - i;
+            int originalLineNumber = originalIndex + 2; // +2 for header and 1-based line numbers
+
+            var parsed = ParseCsvLine(line, originalLineNumber);
+            t[i] = parsed.Time;
+            o[i] = parsed.Open;
+            h[i] = parsed.High;
+            l[i] = parsed.Low;
+            c[i] = parsed.Close;
+            v[i] = parsed.Volume;
+        }
+
+        // Bulk add to series
+        series.Add(t, o, h, l, c, v);
+
+        return series;
+    }
+
+    /// <summary>
+    /// Parses a single CSV line into OHLCV components.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ParsedOhlcv ParseCsvLine(string line, int lineNumber)
+    {
+        // Use Span-based splitting for reduced allocations
+        ReadOnlySpan<char> lineSpan = line.AsSpan();
+
+        int col = 0;
+        int start = 0;
+        OhlcvParseState state = default;
+
+        for (int i = 0; i < lineSpan.Length; i++)
+        {
+            if (lineSpan[i] == ',')
+            {
+                var segment = lineSpan[start..i].Trim();
+                ParseColumn(segment, col, lineNumber, line, ref state);
+                col++;
+                start = i + 1;
+            }
+        }
+
+        // Process the last segment after the final comma
+        if (start <= lineSpan.Length)
+        {
+            var segment = lineSpan[start..].Trim();
+            ParseColumn(segment, col, lineNumber, line, ref state);
+            col++;
+        }
+
+        if (col != 6)
+        {
+            throw new FormatException($"Invalid CSV format at line {lineNumber}. Expected 6 columns, found {col}");
+        }
+
+        return new ParsedOhlcv(state.Time, state.Open, state.High, state.Low, state.Close, state.Volume);
+    }
+
+    /// <summary>
+    /// Parses a single column value into the appropriate OHLCV field.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void ParseColumn(
+        ReadOnlySpan<char> segment,
+        int col,
+        int lineNumber,
+        string line,
+        ref OhlcvParseState state)
+    {
+        switch (col)
+        {
+            case 0: // Timestamp
+                if (!DateTime.TryParseExact(segment, "yyyy-MM-dd", CultureInfo.InvariantCulture,
+                    DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out var timestamp))
+                {
+                    throw new FormatException($"Failed to parse timestamp at line {lineNumber}: {line}");
+                }
+                state.Time = timestamp.Ticks;
+                break;
+            case 1: // Open
+                if (!double.TryParse(segment, NumberStyles.Float, CultureInfo.InvariantCulture, out state.Open))
+                {
+                    throw new FormatException($"Failed to parse open price at line {lineNumber}: {line}");
+                }
+                break;
+            case 2: // High
+                if (!double.TryParse(segment, NumberStyles.Float, CultureInfo.InvariantCulture, out state.High))
+                {
+                    throw new FormatException($"Failed to parse high price at line {lineNumber}: {line}");
+                }
+                break;
+            case 3: // Low
+                if (!double.TryParse(segment, NumberStyles.Float, CultureInfo.InvariantCulture, out state.Low))
+                {
+                    throw new FormatException($"Failed to parse low price at line {lineNumber}: {line}");
+                }
+                break;
+            case 4: // Close
+                if (!double.TryParse(segment, NumberStyles.Float, CultureInfo.InvariantCulture, out state.Close))
+                {
+                    throw new FormatException($"Failed to parse close price at line {lineNumber}: {line}");
+                }
+                break;
+            case 5: // Volume
+                if (!double.TryParse(segment, NumberStyles.Float, CultureInfo.InvariantCulture, out state.Volume))
+                {
+                    throw new FormatException($"Failed to parse volume at line {lineNumber}: {line}");
+                }
+                break;
+            default:
+                // Extra columns are ignored - this handles the default case requirement
+                break;
+        }
+    }
+
+    /// <summary>
+    /// Gets the next bar with full bidirectional control.
+    /// When end of data reached, returns last bar and sets isNew=false.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TBar Next(ref bool isNew)
+    {
+        if (Count == 0)
+        {
+            isNew = false;
+            return default;
+        }
+
+        if (isNew || !_hasCurrentBar)
+        {
+            if (_currentIndex >= Count)
+            {
+                isNew = false;
+                return _currentBar;
+            }
+
+            _currentBar = Data[_currentIndex];
+            _currentIndex++;
+            _hasCurrentBar = true;
+        }
+
+        return _currentBar;
+    }
+
+    /// <summary>
+    /// Gets the next bar with simple control.
+    /// WARNING: This overload discards changes to isNew made by the internal implementation.
+    /// Callers will not observe when streaming ends. Use Next(ref bool isNew) or check HasMore instead.
+    /// </summary>
+    /// <param name="isNew">Whether to advance to the next bar (true) or replay current bar (false).</param>
+    /// <returns>The current or next bar.</returns>
+    /// <remarks>
+    /// Retained for backward compatibility with existing code. Deprecation is intentional to guide
+    /// users toward the ref overload which properly signals end-of-stream conditions.
+    /// </remarks>
+#pragma warning disable S1133 // Deprecated code kept for backward compatibility; removal would be breaking change
+    [Obsolete("Use Next(ref bool isNew) to observe end-of-stream, or check HasMore before calling. This overload discards the modified isNew value.")]
+#pragma warning restore S1133
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public TBar Next(bool isNew = true)
+    {
+        return Next(ref isNew);
+    }
+
+    /// <summary>
+    /// Returns a filtered subset of data matching the criteria.
+    /// Resets streaming position to start of returned data.
+    /// </summary>
+    /// <param name="count">Number of bars to retrieve (must be positive)</param>
+    /// <param name="startTime">Starting timestamp in ticks</param>
+    /// <param name="interval">Time interval between bars</param>
+    /// <returns>A TBarSeries containing the matched bars</returns>
+    /// <exception cref="ArgumentException">Thrown when count is not positive</exception>
+    public TBarSeries Fetch(int count, long startTime, TimeSpan interval)
+    {
+        if (count <= 0)
+        {
+            throw new ArgumentException("Count must be positive", nameof(count));
+        }
+
+        var result = new TBarSeries(count);
+
+        // Find starting index using binary search for better performance
+        int startIndex = FindStartIndex(startTime);
+
+        if (startIndex == -1)
+        {
+            return result;
+        }
+
+        // Collect bars matching interval
+        long expectedTime = startTime;
+        int collected = 0;
+        long tolerance = interval.Ticks / 2;
+
+        for (int i = startIndex; i < Count && collected < count; i++)
+        {
+            var bar = Data[i];
+
+            // Check if bar time matches expected time (within tolerance)
+            long timeDiff = Math.Abs(bar.Time - expectedTime);
+
+            if (timeDiff <= tolerance)
+            {
+                result.Add(bar, isNew: true);
+                collected++;
+                expectedTime += interval.Ticks;
+            }
+            else if (bar.Time > expectedTime)
+            {
+                // Gap in data - skip forward
+                long gaps = (bar.Time - expectedTime) / interval.Ticks;
+                expectedTime += gaps * interval.Ticks;
+
+                if (Math.Abs(bar.Time - expectedTime) <= tolerance)
+                {
+                    result.Add(bar, isNew: true);
+                    collected++;
+                    expectedTime += interval.Ticks;
+                }
+            }
+        }
+
+        // Reset streaming to start of returned data
+        _currentIndex = startIndex;
+        _hasCurrentBar = false;
+
+        return result;
+    }
+
+    /// <summary>
+    /// Finds the starting index for the given start time using binary search.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private int FindStartIndex(long startTime)
+    {
+        if (Count == 0)
+        {
+            return -1;
+        }
+
+        if (Data[0].Time >= startTime)
+        {
+            return 0;
+        }
+
+        if (Data[Count - 1].Time < startTime)
+        {
+            return -1;
+        }
+
+        int left = 0;
+        int right = Count - 1;
+
+        while (left < right)
+        {
+            int mid = left + (right - left) / 2;
+
+            if (Data[mid].Time < startTime)
+            {
+                left = mid + 1;
+            }
+            else
+            {
+                right = mid;
+            }
+        }
+
+        return left;
+    }
+
+    /// <summary>
+    /// Resets the streaming position to the beginning.
+    /// </summary>
+    public void Reset()
+    {
+        _currentIndex = 0;
+        _hasCurrentBar = false;
+        _currentBar = default;
+    }
+
+    /// <summary>
+    /// Resets the streaming position to a specific index.
+    /// </summary>
+    /// <param name="index">The index to reset to (must be valid)</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when index is out of range</exception>
+    public void Reset(int index)
+    {
+        if (index < 0 || index > Count)
+        {
+            throw new ArgumentOutOfRangeException(nameof(index), index, $"Index must be between 0 and {Count}");
+        }
+
+        _currentIndex = index;
+        _hasCurrentBar = false;
+        _currentBar = default;
+    }
+
+    /// <summary>
+    /// Gets the bar at the specified index without affecting streaming position.
+    /// </summary>
+    /// <param name="index">The index of the bar to retrieve</param>
+    /// <returns>The bar at the specified index</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when index is out of range</exception>
+    public TBar GetBar(int index)
+    {
+        if (index < 0 || index >= Count)
+        {
+            throw new ArgumentOutOfRangeException(nameof(index), index, $"Index must be between 0 and {Count - 1}");
+        }
+
+        return Data[index];
+    }
+
+    /// <summary>
+    /// Gets the underlying data series (read-only access).
+    /// </summary>
+    public TBarSeries Data { get; }
+}
@@ -0,0 +1,72 @@
+# CsvFeed Class
+
+`CsvFeed` is a file-based feed implementation that loads historical OHLCV data from CSV files. It supports both streaming access (simulating real-time playback) and batch retrieval.
+
+## Key Features
+
+* **Historical Data Loading**: Reads standard OHLCV CSV files.
+* **Chronological Ordering**: Automatically reverses data if needed (assumes newest-first in file, provides oldest-first).
+* **Streaming Interface**: Implements `IFeed` for consistent usage with other feed types.
+* **Batch Retrieval**: Supports fetching specific time ranges via `Fetch()`.
+
+## CSV Format Requirements
+
+The file must have a header row and follow this column order:
+`timestamp, open, high, low, close, volume`
+
+* **Timestamp**: `YYYY-MM-DD` (assumed UTC midnight)
+* **Prices/Volume**: Numeric values
+
+Example:
+
+```csv
+Date,Open,High,Low,Close,Volume
+2024-01-01,100.0,105.0,99.0,102.5,10000
+2024-01-02,102.5,103.0,101.0,101.5,8500
+```
+
+## Class Definition
+
+```csharp
+public class CsvFeed : IFeed
+{
+    public CsvFeed(string filePath);
+    public TBar Next(bool isNew = true);
+    public TBarSeries Fetch(int count, long startTime, TimeSpan interval);
+}
+```
+
+## Usage
+
+### 1. Loading Data
+
+```csharp
+var feed = new CsvFeed("path/to/data.csv");
+```
+
+### 2. Streaming Data (Simulation)
+
+```csharp
+// Get first bar
+var bar = feed.Next(isNew: true);
+
+// Loop through all data
+while (true)
+{
+    // Process bar...
+    Console.WriteLine(bar);
+
+    // Get next bar
+    bool isNew = true;
+    bar = feed.Next(ref isNew);
+
+    // Stop if no more new data
+    if (!isNew) break;
+}
+```
+
+### 3. Fetching a Batch
+
+```csharp
+long startTime = new DateTime(2024, 1, 1).Ticks;
+var batch = feed.Fetch(10, startTime, TimeSpan.FromDays(1));
@@ -0,0 +1,101 @@
+timestamp,open,high,low,close,volume
+2025-11-25,304.1250,306.0000,297.0600,304.4800,2825322
+2025-11-24,299.1800,307.1800,297.5100,304.1200,6050640
+2025-11-21,293.4800,300.4800,291.8900,297.4400,5710903
+2025-11-20,294.6400,300.7100,290.1600,290.4000,5597028
+2025-11-19,290.5000,291.1099,288.0700,288.5300,3595912
+2025-11-18,297.0000,297.0000,289.9200,289.9500,4861928
+2025-11-17,305.5900,306.0000,296.5100,297.1700,3909741
+2025-11-14,300.0000,307.7200,297.5900,305.6900,3592455
+2025-11-13,312.2900,314.6000,303.6800,304.8600,5310150
+2025-11-12,319.8900,324.9000,314.5324,314.9800,6042686
+2025-11-11,309.0000,317.9100,308.4300,313.7200,4381913
+2025-11-10,306.8200,309.9400,304.2300,309.1300,2975188
+2025-11-07,309.6800,310.0000,302.6301,306.3800,5070773
+2025-11-06,306.7500,315.4400,301.0900,312.4200,6818521
+2025-11-05,301.3800,307.2000,299.7100,306.7700,4633195
+2025-11-04,300.0000,303.1700,296.0000,300.8500,5677330
+2025-11-03,308.0000,312.1411,304.2300,304.7300,4957958
+2025-10-31,312.0000,313.5000,301.6300,307.4100,7697499
+2025-10-30,306.6500,313.7500,305.0200,310.0600,4694275
+2025-10-29,312.7900,314.3300,307.5200,308.2100,4135948
+2025-10-28,312.6000,319.3500,311.4100,312.5700,6044770
+2025-10-27,307.8000,313.5000,302.8800,313.0900,9868151
+2025-10-24,283.7700,310.7500,282.2100,307.4600,16914243
+2025-10-23,264.9500,285.5791,263.5623,285.0000,16676394
+2025-10-22,281.9900,289.1700,281.3500,287.5100,10538480
+2025-10-21,283.3100,285.3100,281.6000,282.0500,4080981
+2025-10-20,281.2500,285.5000,280.9600,283.6500,3494336
+2025-10-17,276.1500,283.4000,275.3500,281.2800,5309565
+2025-10-16,281.1100,282.5600,275.6000,275.9700,2956923
+2025-10-15,278.3800,285.4500,277.0000,280.7500,3346753
+2025-10-14,275.5200,277.5300,272.5469,276.1500,3058149
+2025-10-13,279.7900,282.4399,274.6400,277.2200,4333836
+2025-10-10,288.9700,290.3850,277.5000,277.8200,4508506
+2025-10-09,289.8200,290.1300,283.3200,288.2300,4912375
+2025-10-08,294.1600,294.2000,286.4730,289.4600,5297030
+2025-10-07,295.5500,301.0425,293.2850,293.8700,7190126
+2025-10-06,288.6100,291.4500,287.8000,289.4200,2881947
+2025-10-03,287.5000,293.3200,287.3000,288.3700,4375082
+2025-10-02,285.7900,288.5400,282.7900,286.7200,3814232
+2025-10-01,280.2000,286.5900,280.1500,286.4900,4381338
+2025-09-30,280.8800,286.0250,280.5200,282.1600,5926924
+2025-09-29,286.0000,286.0000,279.6600,279.8000,6022125
+2025-09-26,280.5100,288.8500,280.1100,284.3100,9063938
+2025-09-25,272.9350,284.2300,271.1480,281.4400,11506192
+2025-09-24,272.6200,273.6499,267.3000,267.5300,3159924
+2025-09-23,272.7000,273.2962,269.2650,272.2400,5394121
+2025-09-22,266.6200,272.3100,266.0000,271.3700,5030540
+2025-09-19,266.0500,267.8700,263.6400,266.4000,9858112
+2025-09-18,258.8600,265.2300,256.8004,265.0000,4988421
+2025-09-17,257.4950,260.9644,257.0100,259.0800,3974785
+2025-09-16,256.2600,258.0000,254.4100,257.5200,2719918
+2025-09-15,254.0200,259.0500,254.0000,256.2400,4028365
+2025-09-12,256.9500,257.2500,252.4250,253.4400,3433300
+2025-09-11,257.5600,258.5450,255.6550,257.0100,3576048
+2025-09-10,259.6500,260.0800,254.5600,256.8800,5185420
+2025-09-09,256.1200,260.6600,254.8800,259.1100,4931105
+2025-09-08,248.6300,257.1500,247.0200,256.0900,6940270
+2025-09-05,248.2300,249.0300,245.4500,248.5300,3147478
+2025-09-04,245.4200,249.2800,242.8500,247.1800,4765087
+2025-09-03,240.0200,244.2500,239.4100,244.1000,3156289
+2025-09-02,240.9000,241.5500,238.2500,241.5000,3469501
+2025-08-29,245.2300,245.4599,241.7200,243.4900,2967558
+2025-08-28,245.4300,245.8800,243.3600,245.7300,2820817
+2025-08-27,242.8700,245.9600,242.0000,244.8400,3698372
+2025-08-26,241.0200,244.9800,240.3800,242.6300,5386582
+2025-08-25,242.5650,242.5650,239.4300,239.4300,3513327
+2025-08-22,240.7400,243.6800,240.2200,242.0900,3134882
+2025-08-21,242.2100,242.5000,238.6500,239.4000,2991902
+2025-08-20,242.1100,242.8800,240.3400,242.5500,3240064
+2025-08-19,240.0000,242.8300,239.4900,241.2800,3328305
+2025-08-18,239.5700,241.4200,239.1158,239.4500,3569594
+2025-08-15,237.6100,240.6200,236.7700,239.7200,4344322
+2025-08-14,238.2500,239.0000,235.6200,237.1100,4556725
+2025-08-13,236.2000,240.8411,236.2000,240.0700,5663562
+2025-08-12,236.5300,237.9600,233.3600,234.7700,8800597
+2025-08-11,242.2400,243.1500,234.7000,236.3000,9381960
+2025-08-08,248.8800,249.4800,241.6500,242.2700,6828390
+2025-08-07,252.8100,255.0000,248.8750,250.1600,6251285
+2025-08-06,251.5300,254.3200,249.2800,252.2800,3692105
+2025-08-05,252.0000,252.8000,248.9950,250.6700,5823016
+2025-08-04,251.0500,252.0800,248.1100,251.9800,5280588
+2025-08-01,251.4050,251.4791,245.6100,250.0500,9683404
+2025-07-31,259.5700,259.9900,252.2200,253.1500,6739092
+2025-07-30,261.6000,262.0000,258.9000,260.2600,3718290
+2025-07-29,264.3000,265.7999,261.0200,262.4100,4627265
+2025-07-28,260.3000,264.0000,259.6100,263.2100,5192516
+2025-07-25,260.0200,260.8000,256.3500,259.7200,7758653
+2025-07-24,261.2500,262.0486,252.7500,260.5100,22647720
+2025-07-23,284.3000,288.0800,281.4400,282.0100,8105906
+2025-07-22,284.7400,284.8800,281.2500,281.9600,4824219
+2025-07-21,286.2900,287.7300,284.3800,284.7100,3051791
+2025-07-18,283.3800,287.1600,282.2200,285.8700,4478165
+2025-07-17,281.5000,283.4566,280.9000,282.0000,3337168
+2025-07-16,282.7500,283.8700,279.8700,281.9200,2804831
+2025-07-15,283.7700,284.1550,280.7301,282.7000,2864106
+2025-07-14,282.8300,284.9250,281.7100,283.7900,2857401
+2025-07-11,285.0100,287.4300,282.9200,283.5900,3790679
+2025-07-10,288.9000,288.9000,282.2100,287.4300,3489068
+2025-07-09,291.3900,291.6000,288.6300,290.1400,2971309
+2025-07-08,293.1000,295.6100,289.4900,290.4200,2925329