docs: remove C# Implementation Considerations sections, clean up temp scripts, reorganize test files

- Remove 'C# Implementation Considerations' sections from 34 indicator .md files
- Delete 29 temp PowerShell scripts (_fix_mojibake.ps1, _hex_scan.ps1, etc.)
- Move test files into tests/ subdirectories for consistent project structure
- Add trader-focused bullet points to indicator documentation

lib/oscillators/ultosc/tests/Ultosc.Quantower.Tests.cs

@@ -0,0 +1,105 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public sealed class UltoscIndicatorTests
+{
+    [Fact]
+    public void UltoscIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new UltoscIndicator();
+
+        Assert.Equal(7, indicator.Period1);
+        Assert.Equal(14, indicator.Period2);
+        Assert.Equal(28, indicator.Period3);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("ULTOSC - Ultimate Oscillator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void UltoscIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new UltoscIndicator { Period1 = 7, Period2 = 14, Period3 = 28 };
+
+        Assert.Equal(0, UltoscIndicator.MinHistoryDepths);
+        IWatchlistIndicator watchlistIndicator = indicator;
+        Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void UltoscIndicator_ShortName_IncludesParameters()
+    {
+        var indicator = new UltoscIndicator { Period1 = 5, Period2 = 10, Period3 = 20 };
+        indicator.Initialize();
+
+        Assert.Contains("ULTOSC", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("5", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("10", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("20", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void UltoscIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new UltoscIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Ultosc", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void UltoscIndicator_Initialize_CreatesInternalUltosc()
+    {
+        var indicator = new UltoscIndicator { Period1 = 7, Period2 = 14, Period3 = 28 };
+
+        indicator.Initialize();
+
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void UltoscIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new UltoscIndicator { Period1 = 3, Period2 = 5, Period3 = 7 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void UltoscIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new UltoscIndicator { Period1 = 3, Period2 = 5, Period3 = 7 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Simulate a new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(10), 110, 120, 100, 115);
+        var newArgs = new UpdateArgs(UpdateReason.NewBar);
+        indicator.ProcessUpdate(newArgs);
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(value));
+    }
+}

lib/oscillators/ultosc/tests/Ultosc.Tests.cs

@@ -0,0 +1,507 @@
+namespace QuanTAlib.Tests;
+
+public class UltoscTests
+{
+    // ============== Constructor & Parameter Validation ==============
+
+    [Fact]
+    public void Constructor_InvalidPeriod1_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Ultosc(0, 14, 28));
+        Assert.Throws<ArgumentException>(() => new Ultosc(-1, 14, 28));
+    }
+
+    [Fact]
+    public void Constructor_InvalidPeriod2_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Ultosc(7, 0, 28));
+        Assert.Throws<ArgumentException>(() => new Ultosc(7, -1, 28));
+    }
+
+    [Fact]
+    public void Constructor_InvalidPeriod3_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Ultosc(7, 14, 0));
+        Assert.Throws<ArgumentException>(() => new Ultosc(7, 14, -1));
+    }
+
+    [Fact]
+    public void Constructor_Period1NotLessThanPeriod2_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Ultosc(14, 14, 28));
+        Assert.Throws<ArgumentException>(() => new Ultosc(15, 14, 28));
+    }
+
+    [Fact]
+    public void Constructor_Period2NotLessThanPeriod3_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Ultosc(7, 28, 28));
+        Assert.Throws<ArgumentException>(() => new Ultosc(7, 29, 28));
+    }
+
+    [Fact]
+    public void Constructor_ValidParameters_Succeeds()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        Assert.NotNull(ultosc);
+
+        var ultosc2 = new Ultosc(5, 10, 20);
+        Assert.NotNull(ultosc2);
+    }
+
+    // ============== Basic Functionality ==============
+
+    [Fact]
+    public void BasicCalculation_DoesNotCrash()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        foreach (var bar in bars)
+        {
+            ultosc.Update(bar);
+        }
+
+        Assert.True(double.IsFinite(ultosc.Last.Value));
+    }
+
+    [Fact]
+    public void Calc_ReturnsValue()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var bar = new TBar(DateTime.UtcNow, 100, 105, 95, 102, 1000);
+
+        Assert.Equal(0, ultosc.Last.Value);
+
+        TValue result = ultosc.Update(bar);
+
+        Assert.True(result.Value > 0);
+        Assert.Equal(result.Value, ultosc.Last.Value);
+    }
+
+    [Fact]
+    public void FirstValue_ReturnsValidOscillator()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var bar = new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000);
+        // First bar: BP = Close - Low = 105 - 90 = 15
+        // TR = High - Low = 110 - 90 = 20
+        // Avg = BP/TR = 15/20 = 0.75 for all periods
+        // UO = 100 * (4*0.75 + 2*0.75 + 0.75) / 7 = 100 * 5.25/7 = 75
+
+        TValue result = ultosc.Update(bar);
+
+        Assert.Equal(75.0, result.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Properties_Accessible()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+
+        Assert.Equal(0, ultosc.Last.Value);
+        Assert.False(ultosc.IsHot);
+        Assert.Contains("Ultosc", ultosc.Name, StringComparison.Ordinal);
+        Assert.Equal(28, ultosc.WarmupPeriod);
+
+        var bar = new TBar(DateTime.UtcNow, 100, 105, 95, 102, 1000);
+        ultosc.Update(bar);
+
+        Assert.NotEqual(0, ultosc.Last.Value);
+    }
+
+    // ============== State Management & Bar Correction ==============
+
+    [Fact]
+    public void Calc_IsNew_AcceptsParameter()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+
+        var bar1 = new TBar(DateTime.UtcNow, 100, 105, 95, 102, 1000);
+        ultosc.Update(bar1, isNew: true);
+        double value1 = ultosc.Last.Value;
+
+        var bar2 = new TBar(DateTime.UtcNow.AddMinutes(1), 102, 110, 100, 108, 1000);
+        ultosc.Update(bar2, isNew: true);
+        double value2 = ultosc.Last.Value;
+
+        Assert.NotEqual(value1, value2);
+    }
+
+    [Fact]
+    public void Calc_IsNew_False_UpdatesValue()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+
+        var bar1 = new TBar(DateTime.UtcNow, 100, 105, 95, 102, 1000);
+        ultosc.Update(bar1, isNew: true);
+
+        var bar2 = new TBar(DateTime.UtcNow.AddMinutes(1), 102, 110, 100, 108, 1000);
+        ultosc.Update(bar2, isNew: true);
+        double beforeUpdate = ultosc.Last.Value;
+
+        var bar2Modified = new TBar(DateTime.UtcNow.AddMinutes(1), 102, 120, 90, 108, 1000);
+        ultosc.Update(bar2Modified, isNew: false);
+        double afterUpdate = ultosc.Last.Value;
+
+        Assert.NotEqual(beforeUpdate, afterUpdate);
+    }
+
+    [Fact]
+    public void IsNew_Consistency()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed first 99
+        for (int i = 0; i < 99; i++)
+        {
+            ultosc.Update(bars[i]);
+        }
+
+        // Update with 100th point (isNew=true)
+        ultosc.Update(bars[99], true);
+
+        // Update with modified 100th point (isNew=false)
+        var modifiedBar = new TBar(bars[99].Time, bars[99].Open, bars[99].High + 10.0, bars[99].Low - 10.0, bars[99].Close, bars[99].Volume);
+        double val2 = ultosc.Update(modifiedBar, false).Value;
+
+        // Create new instance and feed up to modified
+        var ultosc2 = new Ultosc(7, 14, 28);
+        for (int i = 0; i < 99; i++)
+        {
+            ultosc2.Update(bars[i]);
+        }
+        double val3 = ultosc2.Update(modifiedBar, true).Value;
+
+        Assert.Equal(val3, val2, 1e-9);
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreToOriginalState()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+        var bars = gbm.Fetch(20, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed 10 new values
+        TBar tenthBar = default;
+        for (int i = 0; i < 10; i++)
+        {
+            tenthBar = bars[i];
+            ultosc.Update(tenthBar, isNew: true);
+        }
+
+        // Remember state after 10 values
+        double stateAfterTen = ultosc.Last.Value;
+
+        // Generate 9 corrections with isNew=false (different values)
+        for (int i = 10; i < 19; i++)
+        {
+            ultosc.Update(bars[i], isNew: false);
+        }
+
+        // Feed the remembered 10th bar again with isNew=false
+        TValue finalResult = ultosc.Update(tenthBar, isNew: false);
+
+        // State should match the original state after 10 values
+        Assert.Equal(stateAfterTen, finalResult.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Reset_Works()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        foreach (var bar in bars)
+        {
+            ultosc.Update(bar);
+        }
+
+        double lastVal = ultosc.Last.Value;
+        Assert.NotEqual(0, lastVal);
+
+        ultosc.Reset();
+        Assert.Equal(0, ultosc.Last.Value);
+        Assert.False(ultosc.IsHot);
+
+        // After reset, should accept new values
+        ultosc.Update(bars[0]);
+        Assert.NotEqual(0, ultosc.Last.Value);
+    }
+
+    // ============== Warmup & Convergence ==============
+
+    [Fact]
+    public void IsHot_BecomesTrueAfterWarmup()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+
+        Assert.False(ultosc.IsHot);
+
+        int steps = 0;
+        var baseTime = DateTime.UtcNow;
+        while (!ultosc.IsHot && steps < 100)
+        {
+            var bar = new TBar(baseTime.AddMinutes(steps), 100, 110, 90, 100, 1000);
+            ultosc.Update(bar);
+            steps++;
+        }
+
+        Assert.True(ultosc.IsHot);
+        Assert.True(steps > 0);
+    }
+
+    [Fact]
+    public void WarmupPeriod_IsPositive()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        Assert.True(ultosc.WarmupPeriod > 0);
+        Assert.Equal(28, ultosc.WarmupPeriod);
+
+        var ultosc2 = new Ultosc(5, 10, 20);
+        Assert.Equal(20, ultosc2.WarmupPeriod);
+    }
+
+    // ============== NaN/Infinity Handling ==============
+
+    [Fact]
+    public void NaN_Input_UsesLastValidValue()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+
+        var bar1 = new TBar(DateTime.UtcNow, 100, 105, 95, 102, 1000);
+        ultosc.Update(bar1);
+
+        var bar2 = new TBar(DateTime.UtcNow.AddMinutes(1), 102, 110, 98, 108, 1000);
+        ultosc.Update(bar2);
+
+        // Feed bar with NaN values
+        var barWithNaN = new TBar(DateTime.UtcNow.AddMinutes(2), double.NaN, 115, 100, 112, 1000);
+        var resultAfterNaN = ultosc.Update(barWithNaN);
+
+        // Result should be finite
+        Assert.True(double.IsFinite(resultAfterNaN.Value));
+    }
+
+    [Fact]
+    public void Infinity_Input_UsesLastValidValue()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+
+        var bar1 = new TBar(DateTime.UtcNow, 100, 105, 95, 102, 1000);
+        ultosc.Update(bar1);
+
+        var bar2 = new TBar(DateTime.UtcNow.AddMinutes(1), 102, 110, 98, 108, 1000);
+        ultosc.Update(bar2);
+
+        // Feed bar with Infinity
+        var barWithInf = new TBar(DateTime.UtcNow.AddMinutes(2), 108, double.PositiveInfinity, 100, 112, 1000);
+        var resultAfterInf = ultosc.Update(barWithInf);
+
+        // Result should be finite or infinity (depending on implementation)
+        Assert.True(double.IsFinite(resultAfterInf.Value) || double.IsPositiveInfinity(resultAfterInf.Value));
+    }
+
+    // ============== Consistency Tests ==============
+
+    [Fact]
+    public void BatchCalc_MatchesIterativeCalc()
+    {
+        var ultoscIterative = new Ultosc(7, 14, 28);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Calculate iteratively
+        var iterativeResults = new TSeries();
+        foreach (var bar in bars)
+        {
+            iterativeResults.Add(ultoscIterative.Update(bar));
+        }
+
+        // Calculate batch
+        var batchResults = Ultosc.Batch(bars, 7, 14, 28);
+
+        // Compare
+        Assert.Equal(iterativeResults.Count, batchResults.Count);
+        for (int i = 0; i < iterativeResults.Count; i++)
+        {
+            Assert.Equal(iterativeResults[i].Value, batchResults[i].Value, 1e-10);
+        }
+    }
+
+    [Fact]
+    public void TBarSeries_Update_MatchesStreaming()
+    {
+        var ultosc1 = new Ultosc(7, 14, 28);
+        var ultosc2 = new Ultosc(7, 14, 28);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Streaming
+        foreach (var bar in bars)
+        {
+            ultosc1.Update(bar);
+        }
+
+        // Batch
+        ultosc2.Update(bars);
+
+        Assert.Equal(ultosc1.Last.Value, ultosc2.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Chainability_Works()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var result = ultosc.Update(bars);
+        Assert.Equal(50, result.Count);
+        Assert.Equal(ultosc.Last.Value, result.Last.Value);
+    }
+
+    // ============== Oscillator Range Tests ==============
+
+    [Fact]
+    public void Oscillator_ReturnsValueBetween0And100()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        foreach (var bar in bars)
+        {
+            var result = ultosc.Update(bar);
+            Assert.InRange(result.Value, 0.0, 100.0);
+        }
+    }
+
+    [Fact]
+    public void StrongUptrend_ReturnsHighValues()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+        var baseTime = DateTime.UtcNow;
+
+        // Create strong uptrend bars where Close is always at High
+        for (int i = 0; i < 20; i++)
+        {
+            double basePrice = 100 + (i * 5); // Rising prices
+            var bar = new TBar(baseTime.AddMinutes(i), basePrice, basePrice + 10, basePrice - 2, basePrice + 10, 1000);
+            ultosc.Update(bar);
+        }
+
+        // In strong uptrend with Close at High, BP/TR should be high
+        Assert.True(ultosc.Last.Value > 50);
+    }
+
+    [Fact]
+    public void StrongDowntrend_ReturnsLowValues()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+        var baseTime = DateTime.UtcNow;
+
+        // Create strong downtrend bars where Close is always at Low
+        for (int i = 0; i < 20; i++)
+        {
+            double basePrice = 200 - (i * 5); // Falling prices
+            var bar = new TBar(baseTime.AddMinutes(i), basePrice, basePrice + 2, basePrice - 10, basePrice - 10, 1000);
+            ultosc.Update(bar);
+        }
+
+        // In strong downtrend with Close at Low, BP/TR should be low
+        Assert.True(ultosc.Last.Value < 50);
+    }
+
+    // ============== Static Batch Method ==============
+
+    [Fact]
+    public void StaticBatch_Works()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var results = Ultosc.Batch(bars, 7, 14, 28);
+
+        Assert.Equal(50, results.Count);
+        Assert.True(double.IsFinite(results.Last.Value));
+    }
+
+    // ============== Edge Cases ==============
+
+    [Fact]
+    public void SingleBar_ReturnsValidResult()
+    {
+        var ultosc = new Ultosc(7, 14, 28);
+        var bar = new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000);
+
+        var result = ultosc.Update(bar);
+
+        Assert.True(double.IsFinite(result.Value));
+        // BP = Close - Low = 105 - 90 = 15
+        // TR = High - Low = 110 - 90 = 20
+        // Avg = 15/20 = 0.75
+        // UO = 100 * (4*0.75 + 2*0.75 + 0.75) / 7 = 75
+        Assert.Equal(75.0, result.Value, 1e-10);
+    }
+
+    [Fact]
+    public void FlatBars_ReturnsFifty()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+
+        // All bars have same OHLC values (flat market)
+        for (int i = 0; i < 20; i++)
+        {
+            var bar = new TBar(DateTime.UtcNow.AddMinutes(i), 100, 100, 100, 100, 1000);
+            ultosc.Update(bar);
+        }
+
+        // For flat bars: BP = 0, TR = 0, so BP/TR = 0/0 handled as 0.5
+        // UO = 100 * 0.5 * 7 / 7 = 50
+        Assert.Equal(50.0, ultosc.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void CloseAtHigh_ReturnsHundred()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+
+        // All bars have Close at High
+        for (int i = 0; i < 20; i++)
+        {
+            var bar = new TBar(DateTime.UtcNow.AddMinutes(i), 100, 110, 90, 110, 1000);
+            ultosc.Update(bar);
+        }
+
+        // BP = Close - TrueLow = 110 - 90 = 20
+        // TR = TrueHigh - TrueLow = 110 - 90 = 20
+        // Avg = 20/20 = 1.0
+        // UO = 100 * (4*1 + 2*1 + 1) / 7 = 100
+        Assert.Equal(100.0, ultosc.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void CloseAtLow_ReturnsZero()
+    {
+        var ultosc = new Ultosc(3, 5, 7);
+
+        // All bars have Close at Low
+        for (int i = 0; i < 20; i++)
+        {
+            var bar = new TBar(DateTime.UtcNow.AddMinutes(i), 100, 110, 90, 90, 1000);
+            ultosc.Update(bar);
+        }
+
+        // BP = Close - TrueLow = 90 - 90 = 0
+        // TR = TrueHigh - TrueLow = 110 - 90 = 20
+        // Avg = 0/20 = 0.0
+        // UO = 100 * (4*0 + 2*0 + 0) / 7 = 0
+        Assert.Equal(0.0, ultosc.Last.Value, 1e-10);
+    }
+}

lib/oscillators/ultosc/tests/Ultosc.Validation.Tests.cs

@@ -0,0 +1,506 @@
+using OoplesFinance.StockIndicators;
+using OoplesFinance.StockIndicators.Models;
+using Skender.Stock.Indicators;
+using TALib;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+/// <summary>
+/// Ultimate Oscillator validation tests.
+/// Cross-validates against Skender.Stock.Indicators.GetUltimate,
+/// TALib.NETCore, Tulip.NETCore, OoplesFinance, and self-consistency checks.
+/// </summary>
+public sealed class UltoscValidationTests : IDisposable
+{
+    private readonly ValidationTestData _data = new();
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public UltoscValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (!_disposed && disposing)
+        {
+            _data.Dispose();
+            _disposed = true;
+        }
+    }
+
+    private static TBarSeries GenerateSeries(int count, int seed = 42)
+    {
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: seed);
+        return gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+    }
+
+    // --- A) Streaming vs Batch agreement ---
+
+    [Fact]
+    public void Streaming_Matches_Batch()
+    {
+        var series = GenerateSeries(300);
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+
+        var ultosc = new Ultosc(p1, p2, p3);
+        for (int i = 0; i < series.Count; i++)
+        {
+            ultosc.Update(series[i]);
+        }
+
+        var batch = Ultosc.Batch(series, p1, p2, p3);
+
+        Assert.Equal(ultosc.Last.Value, batch[^1].Value, 1e-6);
+    }
+
+    // --- B) Span matches TBarSeries ---
+
+    [Fact]
+    public void Span_Matches_TBarSeries()
+    {
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+
+        double[] hData = _data.HighPrices.ToArray();
+        double[] lData = _data.LowPrices.ToArray();
+        double[] cData = _data.ClosePrices.ToArray();
+        double[] spanOutput = new double[hData.Length];
+
+        Ultosc.Batch(hData, lData, cData, spanOutput, p1, p2, p3);
+
+        var ultosc = new Ultosc(p1, p2, p3);
+        var tbarResult = ultosc.Update(_data.Bars);
+
+        for (int i = 0; i < tbarResult.Count; i++)
+        {
+            Assert.Equal(tbarResult[i].Value, spanOutput[i], 1e-10);
+        }
+
+        _output.WriteLine("Span calculation matches TBarSeries batch calculation.");
+    }
+
+    // --- C) Constant bars → Ultosc = 50 ---
+
+    [Fact]
+    public void ConstantBars_ValueIs_50()
+    {
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+        int count = 60;
+
+        var bars = new TBarSeries();
+        for (int i = 0; i < count; i++)
+        {
+            bars.Add(new TBar(DateTime.UtcNow.AddMinutes(i), 50, 50, 50, 50, 100));
+        }
+
+        var result = Ultosc.Batch(bars, p1, p2, p3);
+
+        // When all OHLC are identical, BP=0, TR=0 → avg=0.5 each → Ultosc=50
+        for (int i = p3; i < count; i++)
+        {
+            Assert.Equal(50.0, result.Values[i], 1e-10);
+        }
+    }
+
+    // --- D) Directional correctness ---
+
+    [Fact]
+    public void Rising_Produces_HighValues()
+    {
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+
+        var bars = new TBarSeries();
+        for (int i = 0; i < 60; i++)
+        {
+            double price = 100.0 + (i * 2.0);
+            bars.Add(new TBar(DateTime.UtcNow.AddMinutes(i), price, price + 1, price - 1, price + 0.5, 100));
+        }
+
+        var ultosc = new Ultosc(p1, p2, p3);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ultosc.Update(bars[i]);
+        }
+
+        // Close consistently near high → strong buying pressure → Ultosc > 50
+        Assert.True(ultosc.Last.Value > 50.0,
+            $"Expected > 50 for rising prices, got {ultosc.Last.Value}");
+    }
+
+    [Fact]
+    public void Falling_Produces_LowValues()
+    {
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+
+        var bars = new TBarSeries();
+        for (int i = 0; i < 60; i++)
+        {
+            double price = 200.0 - (i * 2.0);
+            bars.Add(new TBar(DateTime.UtcNow.AddMinutes(i), price, price + 1, price - 1, price - 0.5, 100));
+        }
+
+        var ultosc = new Ultosc(p1, p2, p3);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ultosc.Update(bars[i]);
+        }
+
+        // Close consistently near low → weak buying pressure → Ultosc < 50
+        Assert.True(ultosc.Last.Value < 50.0,
+            $"Expected < 50 for falling prices, got {ultosc.Last.Value}");
+    }
+
+    // --- E) Cross-validation with Skender (batch) ---
+
+    [Fact]
+    public void Skender_Batch_Matches()
+    {
+        int[][] periodSets = [[7, 14, 28]];
+
+        foreach (var periods in periodSets)
+        {
+            int p1 = periods[0];
+            int p2 = periods[1];
+            int p3 = periods[2];
+
+            var ultosc = new Ultosc(p1, p2, p3);
+            var qResult = ultosc.Update(_data.Bars);
+
+            var sResult = _data.SkenderQuotes.GetUltimate(p1, p2, p3).ToList();
+
+            ValidationHelper.VerifyData(qResult, sResult, (s) => s.Ultimate, tolerance: ValidationHelper.SkenderTolerance);
+        }
+
+        _output.WriteLine("Skender batch validation passed.");
+    }
+
+    // --- F) Cross-validation with Skender (streaming) ---
+
+    [Fact]
+    public void Skender_Streaming_Matches()
+    {
+        int[][] periodSets = [[7, 14, 28]];
+
+        foreach (var periods in periodSets)
+        {
+            int p1 = periods[0];
+            int p2 = periods[1];
+            int p3 = periods[2];
+
+            var ultosc = new Ultosc(p1, p2, p3);
+            var qResults = new List<double>();
+            foreach (var item in _data.Bars)
+            {
+                qResults.Add(ultosc.Update(item).Value);
+            }
+
+            var sResult = _data.SkenderQuotes.GetUltimate(p1, p2, p3).ToList();
+
+            ValidationHelper.VerifyData(qResults, sResult, (s) => s.Ultimate, tolerance: ValidationHelper.SkenderTolerance);
+        }
+
+        _output.WriteLine("Skender streaming validation passed.");
+    }
+
+    // --- G) Cross-validation with TA-Lib (batch) ---
+
+    [Fact]
+    public void TALib_Batch_Matches()
+    {
+        int[][] periodSets = [[7, 14, 28]];
+
+        double[] hData = _data.HighPrices.ToArray();
+        double[] lData = _data.LowPrices.ToArray();
+        double[] cData = _data.ClosePrices.ToArray();
+        double[] output = new double[hData.Length];
+
+        foreach (var periods in periodSets)
+        {
+            int p1 = periods[0];
+            int p2 = periods[1];
+            int p3 = periods[2];
+
+            var ultosc = new Ultosc(p1, p2, p3);
+            var qResult = ultosc.Update(_data.Bars);
+
+            var retCode = TALib.Functions.UltOsc(hData, lData, cData, 0..^0, output, out var outRange, p1, p2, p3);
+            Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+            int lookback = TALib.Functions.UltOscLookback(p1, p2, p3);
+
+            ValidationHelper.VerifyData(qResult, output, outRange, lookback, tolerance: ValidationHelper.TalibTolerance);
+        }
+
+        _output.WriteLine("TA-Lib batch validation passed.");
+    }
+
+    // --- H) Cross-validation with TA-Lib (streaming) ---
+
+    [Fact]
+    public void TALib_Streaming_Matches()
+    {
+        int[][] periodSets = [[7, 14, 28]];
+
+        double[] hData = _data.HighPrices.ToArray();
+        double[] lData = _data.LowPrices.ToArray();
+        double[] cData = _data.ClosePrices.ToArray();
+        double[] output = new double[hData.Length];
+
+        foreach (var periods in periodSets)
+        {
+            int p1 = periods[0];
+            int p2 = periods[1];
+            int p3 = periods[2];
+
+            var ultosc = new Ultosc(p1, p2, p3);
+            var qResults = new List<double>();
+            foreach (var item in _data.Bars)
+            {
+                qResults.Add(ultosc.Update(item).Value);
+            }
+
+            var retCode = TALib.Functions.UltOsc(hData, lData, cData, 0..^0, output, out var outRange, p1, p2, p3);
+            Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+            int lookback = TALib.Functions.UltOscLookback(p1, p2, p3);
+
+            ValidationHelper.VerifyData(qResults, output, outRange, lookback, tolerance: ValidationHelper.TalibTolerance);
+        }
+
+        _output.WriteLine("TA-Lib streaming validation passed.");
+    }
+
+    // --- I) Cross-validation with Tulip (batch) ---
+
+    [Fact]
+    public void Tulip_Batch_Matches()
+    {
+        int[][] periodSets = [[7, 14, 28]];
+
+        double[] hData = _data.HighPrices.ToArray();
+        double[] lData = _data.LowPrices.ToArray();
+        double[] cData = _data.ClosePrices.ToArray();
+
+        foreach (var periods in periodSets)
+        {
+            int p1 = periods[0];
+            int p2 = periods[1];
+            int p3 = periods[2];
+
+            var ultosc = new Ultosc(p1, p2, p3);
+            var qResult = ultosc.Update(_data.Bars);
+
+            var ultoscIndicator = Tulip.Indicators.ultosc;
+            double[][] inputs = [hData, lData, cData];
+            double[] options = [p1, p2, p3];
+
+            int lookback = ultoscIndicator.Start(options);
+            double[][] outputs = [new double[hData.Length - lookback]];
+
+            ultoscIndicator.Run(inputs, options, outputs);
+            var tResult = outputs[0];
+
+            ValidationHelper.VerifyData(qResult, tResult, lookback, tolerance: ValidationHelper.TulipTolerance);
+        }
+
+        _output.WriteLine("Tulip batch validation passed.");
+    }
+
+    // --- J) Cross-validation with Tulip (streaming) ---
+
+    [Fact]
+    public void Tulip_Streaming_Matches()
+    {
+        int[][] periodSets = [[7, 14, 28]];
+
+        double[] hData = _data.HighPrices.ToArray();
+        double[] lData = _data.LowPrices.ToArray();
+        double[] cData = _data.ClosePrices.ToArray();
+
+        foreach (var periods in periodSets)
+        {
+            int p1 = periods[0];
+            int p2 = periods[1];
+            int p3 = periods[2];
+
+            var ultosc = new Ultosc(p1, p2, p3);
+            var qResults = new List<double>();
+            foreach (var item in _data.Bars)
+            {
+                qResults.Add(ultosc.Update(item).Value);
+            }
+
+            var ultoscIndicator = Tulip.Indicators.ultosc;
+            double[][] inputs = [hData, lData, cData];
+            double[] options = [p1, p2, p3];
+
+            int lookback = ultoscIndicator.Start(options);
+            double[][] outputs = [new double[hData.Length - lookback]];
+
+            ultoscIndicator.Run(inputs, options, outputs);
+            var tResult = outputs[0];
+
+            ValidationHelper.VerifyData(qResults, tResult, lookback, tolerance: ValidationHelper.TulipTolerance);
+        }
+
+        _output.WriteLine("Tulip streaming validation passed.");
+    }
+
+    // --- K) Cross-validation with Ooples ---
+
+    [Fact]
+    public void Ooples_Batch_Matches()
+    {
+        int[][] periodSets = [[7, 14, 28]];
+
+        var ooplesData = _data.SkenderQuotes.Select(q => new TickerData
+        {
+            Date = q.Date,
+            Close = (double)q.Close,
+            High = (double)q.High,
+            Low = (double)q.Low,
+            Open = (double)q.Open,
+            Volume = (double)q.Volume
+        }).ToList();
+
+        foreach (var periods in periodSets)
+        {
+            int p1 = periods[0];
+            int p2 = periods[1];
+            int p3 = periods[2];
+
+            var ultosc = new Ultosc(p1, p2, p3);
+            var qResult = ultosc.Update(_data.Bars);
+
+            var stockData = new StockData(ooplesData);
+            var sResult = stockData.CalculateUltimateOscillator(p1, p2, p3).OutputValues.Values.First();
+
+            ValidationHelper.VerifyData(qResult, sResult, (s) => s, 100, ValidationHelper.OoplesTolerance);
+        }
+
+        _output.WriteLine("Ooples batch validation passed.");
+    }
+
+    // --- L) Range bounded [0, 100] ---
+
+    [Fact]
+    public void Output_Bounded_0_To_100()
+    {
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+
+        var result = Ultosc.Batch(_data.Bars, p1, p2, p3);
+
+        for (int i = p3; i < _data.Bars.Count; i++)
+        {
+            double val = result.Values[i];
+            Assert.True(val >= 0.0 && val <= 100.0,
+                $"Ultosc value {val} out of [0, 100] range at bar {i}");
+        }
+
+        _output.WriteLine("All Ultosc values within [0, 100] range.");
+    }
+
+    // --- M) Determinism ---
+
+    [Fact]
+    public void Deterministic_Across_Runs()
+    {
+        var series = GenerateSeries(200, seed: 99);
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+
+        var r1 = Ultosc.Batch(series, p1, p2, p3);
+        var r2 = Ultosc.Batch(series, p1, p2, p3);
+
+        for (int i = 0; i < series.Count; i++)
+        {
+            Assert.Equal(r1.Values[i], r2.Values[i], 15);
+        }
+    }
+
+    // --- N) Multi-period consistency ---
+
+    [Fact]
+    public void Different_Periods_Produce_Different_Results()
+    {
+        var series = GenerateSeries(200);
+
+        var r1 = Ultosc.Batch(series, 5, 10, 20);
+        var r2 = Ultosc.Batch(series, 7, 14, 28);
+
+        bool anyDifferent = false;
+        for (int i = 28; i < 200; i++)
+        {
+            if (Math.Abs(r1.Values[i] - r2.Values[i]) > 0.01)
+            {
+                anyDifferent = true;
+                break;
+            }
+        }
+
+        Assert.True(anyDifferent);
+    }
+
+    // --- O) Calculate returns consistent results ---
+
+    [Fact]
+    public void Calculate_Produces_Consistent_Results()
+    {
+        var series = GenerateSeries(100);
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+
+        var (results, indicator) = Ultosc.Calculate(series, p1, p2, p3);
+
+        Assert.Equal(100, results.Count);
+        Assert.True(indicator.IsHot);
+        Assert.True(double.IsFinite(indicator.Last.Value));
+    }
+
+    // --- P) All outputs finite after warmup ---
+
+    [Fact]
+    public void AllOutputsFinite_AfterWarmup()
+    {
+        const int p1 = 7;
+        const int p2 = 14;
+        const int p3 = 28;
+        var ultosc = new Ultosc(p1, p2, p3);
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            var result = ultosc.Update(_data.Bars[i]);
+
+            if (i >= p3)
+            {
+                Assert.True(double.IsFinite(result.Value),
+                    $"Non-finite output at bar {i}: {result.Value}");
+            }
+        }
+
+        _output.WriteLine("All outputs finite after warmup verified.");
+    }
+}