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/dosc/tests/Dosc.Quantower.Tests.cs

@@ -0,0 +1,162 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class DoscIndicatorTests
+{
+    [Fact]
+    public void DoscIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new DoscIndicator();
+
+        Assert.Equal(14, indicator.RsiPeriod);
+        Assert.Equal(5, indicator.Ema1Period);
+        Assert.Equal(3, indicator.Ema2Period);
+        Assert.Equal(9, indicator.SigPeriod);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("DOSC - Derivative Oscillator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void DoscIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new DoscIndicator();
+
+        Assert.Equal(0, DoscIndicator.MinHistoryDepths);
+        Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void DoscIndicator_ShortName_IncludesAllParams()
+    {
+        var indicator = new DoscIndicator { RsiPeriod = 10, Ema1Period = 4, Ema2Period = 2, SigPeriod = 7 };
+
+        Assert.Contains("DOSC", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("10", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("4", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("2", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("7", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DoscIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new DoscIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Dosc.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DoscIndicator_Initialize_CreatesInternalIndicator()
+    {
+        var indicator = new DoscIndicator { RsiPeriod = 14, Ema1Period = 5, Ema2Period = 3, SigPeriod = 9 };
+
+        indicator.Initialize();
+
+        // Single output line series
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void DoscIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new DoscIndicator { RsiPeriod = 3, Ema1Period = 2, Ema2Period = 2, SigPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void DoscIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new DoscIndicator { RsiPeriod = 3, Ema1Period = 2, Ema2Period = 2, SigPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void DoscIndicator_InternalIndicator_HandlesBarCorrection()
+    {
+        // Use alternating zigzag data so RSI is not a degenerate 100/0, ensuring DOSC != 0
+        // and a large-drop correction produces a measurably different result.
+        var ma = new Dosc(3, 2, 2, 3);
+        var now = DateTime.UtcNow;
+        double[] prices = [100, 102, 99, 103, 97, 104, 98, 105, 97, 106];
+
+        for (int i = 0; i < prices.Length; i++)
+        {
+            ma.Update(new TValue(now.AddMinutes(i).Ticks, prices[i]), isNew: true);
+        }
+
+        double beforeCorrection = ma.Last.Value;
+
+        // Correct last bar with a steep drop — RSI collapses, DOSC must change
+        ma.Update(new TValue(now.AddMinutes(9).Ticks, 50), isNew: false);
+        double afterCorrection = ma.Last.Value;
+
+        Assert.NotEqual(beforeCorrection, afterCorrection);
+        Assert.True(double.IsFinite(afterCorrection));
+    }
+
+    [Fact]
+    public void DoscIndicator_DifferentSourceTypes()
+    {
+        foreach (SourceType sourceType in new[] { SourceType.Close, SourceType.Open, SourceType.High, SourceType.Low })
+        {
+            var indicator = new DoscIndicator();
+            indicator.Source = sourceType;
+            Assert.Equal(sourceType, indicator.Source);
+        }
+    }
+
+    [Fact]
+    public void DoscIndicator_MultipleHistoricalBars()
+    {
+        var indicator = new DoscIndicator { RsiPeriod = 5, Ema1Period = 3, Ema2Period = 2, SigPeriod = 4 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
+            indicator.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        Assert.Equal(30, indicator.LinesSeries[0].Count);
+
+        for (int i = 0; i < 30; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(i)));
+        }
+    }
+
+    [Fact]
+    public void DoscIndicator_PeriodChange_UpdatesConfig()
+    {
+        var indicator = new DoscIndicator();
+        indicator.RsiPeriod = 7;
+        Assert.Equal(7, indicator.RsiPeriod);
+
+        indicator.SigPeriod = 5;
+        Assert.Equal(5, indicator.SigPeriod);
+    }
+}

lib/oscillators/dosc/tests/Dosc.Tests.cs

@@ -0,0 +1,436 @@
+namespace QuanTAlib;
+
+public class DoscTests
+{
+    private const int DefaultRsi = 14;
+    private const int DefaultEma1 = 5;
+    private const int DefaultEma2 = 3;
+    private const int DefaultSig = 9;
+    private const double Tolerance = 1e-12;
+
+    private static TSeries MakeSeries(int count = 500)
+    {
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.5, seed: 42);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        return bars.Close;
+    }
+
+    // ========== A) Constructor Validation ==========
+
+    [Fact]
+    public void Constructor_ZeroRsiPeriod_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Dosc(rsiPeriod: 0));
+        Assert.Equal("rsiPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_NegativeRsiPeriod_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Dosc(rsiPeriod: -5));
+        Assert.Equal("rsiPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_ZeroEma1Period_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Dosc(rsiPeriod: 14, ema1Period: 0));
+        Assert.Equal("ema1Period", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_ZeroEma2Period_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Dosc(rsiPeriod: 14, ema1Period: 5, ema2Period: 0));
+        Assert.Equal("ema2Period", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_ZeroSigPeriod_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Dosc(rsiPeriod: 14, ema1Period: 5, ema2Period: 3, sigPeriod: 0));
+        Assert.Equal("sigPeriod", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_ValidDefaults_SetsNameAndWarmup()
+    {
+        var indicator = new Dosc();
+        Assert.Equal("Dosc(14,5,3,9)", indicator.Name);
+        Assert.Equal(14 + 9, indicator.WarmupPeriod); // rsiPeriod + sigPeriod
+    }
+
+    [Fact]
+    public void Constructor_CustomParams_SetsName()
+    {
+        var indicator = new Dosc(rsiPeriod: 7, ema1Period: 3, ema2Period: 2, sigPeriod: 5);
+        Assert.Equal("Dosc(7,3,2,5)", indicator.Name);
+    }
+
+    // ========== B) Basic Calculation ==========
+
+    [Fact]
+    public void Update_ReturnsTValue_WithValidProperties()
+    {
+        var indicator = new Dosc();
+        var input = new TValue(DateTime.UtcNow, 100.0);
+        TValue result = indicator.Update(input);
+
+        Assert.Equal(input.Time, result.Time);
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Update_AfterWarmup_IsHotBecomesTrue()
+    {
+        var indicator = new Dosc();
+        Assert.False(indicator.IsHot);
+
+        for (int i = 0; i < 500; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.1));
+        }
+
+        Assert.True(indicator.IsHot);
+    }
+
+    [Fact]
+    public void Update_LastProperty_MatchesReturnValue()
+    {
+        var indicator = new Dosc();
+        TValue result = indicator.Update(new TValue(DateTime.UtcNow, 42.0));
+        Assert.Equal(result.Value, indicator.Last.Value, Tolerance);
+    }
+
+    // ========== C) State + Bar Correction ==========
+
+    [Fact]
+    public void IsNew_True_AdvancesState()
+    {
+        var indicator = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+
+        // Warm up well past the period threshold
+        for (int i = 0; i < DefaultRsi + DefaultSig + 10; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.5), isNew: true);
+        }
+
+        TValue r1 = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(50), 120.0), isNew: true);
+        TValue r2 = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(51), 80.0), isNew: true);
+
+        Assert.NotEqual(r1.Value, r2.Value);
+    }
+
+    [Fact]
+    public void IsNew_False_RewritesCurrentBar()
+    {
+        var indicator = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+
+        for (int i = 0; i < 60; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
+        }
+
+        indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(60), 200.0), isNew: true);
+        double afterNew = indicator.Last.Value;
+
+        indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(60), 150.0), isNew: false);
+        double afterCorrection = indicator.Last.Value;
+
+        Assert.NotEqual(afterNew, afterCorrection);
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreState()
+    {
+        var indicator = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+        TSeries data = MakeSeries();
+
+        for (int i = 0; i < 50; i++)
+        {
+            indicator.Update(data[i], isNew: true);
+        }
+
+        indicator.Update(data[50], isNew: true);
+
+        for (int j = 0; j < 5; j++)
+        {
+            indicator.Update(data[50], isNew: false);
+        }
+
+        double afterCorrections = indicator.Last.Value;
+
+        var fresh = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+        for (int i = 0; i <= 50; i++)
+        {
+            fresh.Update(data[i], isNew: true);
+        }
+
+        Assert.Equal(fresh.Last.Value, afterCorrections, Tolerance);
+    }
+
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var indicator = new Dosc();
+
+        for (int i = 0; i < 100; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
+        }
+
+        Assert.True(indicator.IsHot);
+
+        indicator.Reset();
+
+        Assert.False(indicator.IsHot);
+        Assert.Equal(default, indicator.Last);
+    }
+
+    // ========== D) Warmup/Convergence ==========
+
+    [Fact]
+    public void IsHot_FlipsAtCorrectTime()
+    {
+        var indicator = new Dosc(rsiPeriod: 5, ema1Period: 3, ema2Period: 2, sigPeriod: 5);
+        int hotAt = -1;
+
+        for (int i = 0; i < 200; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.1));
+            if (indicator.IsHot && hotAt < 0)
+            {
+                hotAt = i;
+                break;
+            }
+        }
+
+        Assert.InRange(hotAt, 1, 200);
+    }
+
+    // ========== E) Robustness ==========
+
+    [Fact]
+    public void NaN_Input_UsesLastValidValue()
+    {
+        var indicator = new Dosc();
+
+        for (int i = 0; i < 30; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
+        }
+
+        TValue nanResult = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(30), double.NaN));
+        Assert.True(double.IsFinite(nanResult.Value));
+    }
+
+    [Fact]
+    public void Infinity_Input_UsesLastValidValue()
+    {
+        var indicator = new Dosc();
+
+        for (int i = 0; i < 30; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
+        }
+
+        TValue infResult = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(30), double.PositiveInfinity));
+        Assert.True(double.IsFinite(infResult.Value));
+    }
+
+    [Fact]
+    public void BatchNaN_DoesNotPropagate()
+    {
+        double[] source = new double[100];
+        double[] output = new double[100];
+
+        for (int i = 0; i < 100; i++)
+        {
+            source[i] = 100.0 + i * 0.5;
+        }
+
+        source[50] = double.NaN;
+        source[51] = double.NaN;
+
+        Dosc.Batch(source, output, 14, 5, 3, 9);
+
+        for (int i = 0; i < 100; i++)
+        {
+            Assert.True(double.IsFinite(output[i]), $"Output[{i}] is not finite");
+        }
+    }
+
+    // ========== F) Consistency (4 API modes) ==========
+
+    [Fact]
+    public void AllModes_ProduceSameResult()
+    {
+        int rsi = 7, e1 = 3, e2 = 2, sig = 5;
+        TSeries data = MakeSeries();
+
+        // 1. Batch (TSeries)
+        TSeries batchResults = Dosc.Batch(data, rsi, e1, e2, sig);
+        double expected = batchResults.Last.Value;
+
+        // 2. Span batch
+        var values = data.Values.ToArray();
+        var spanOutput = new double[values.Length];
+        Dosc.Batch(new ReadOnlySpan<double>(values), spanOutput, rsi, e1, e2, sig);
+        double spanResult = spanOutput[^1];
+
+        // 3. Streaming
+        var streaming = new Dosc(rsi, e1, e2, sig);
+        for (int i = 0; i < data.Count; i++)
+        {
+            streaming.Update(data[i]);
+        }
+        double streamingResult = streaming.Last.Value;
+
+        // 4. Eventing
+        var pubSource = new TSeries();
+        var eventBased = new Dosc(pubSource, rsi, e1, e2, sig);
+        for (int i = 0; i < data.Count; i++)
+        {
+            pubSource.Add(data[i]);
+        }
+        double eventingResult = eventBased.Last.Value;
+
+        Assert.Equal(expected, spanResult, precision: 9);
+        Assert.Equal(expected, streamingResult, precision: 9);
+        Assert.Equal(expected, eventingResult, precision: 9);
+    }
+
+    // ========== G) Span API Tests ==========
+
+    [Fact]
+    public void SpanBatch_MismatchedLengths_ThrowsArgumentException()
+    {
+        double[] source = new double[10];
+        double[] output = new double[5];
+
+        var ex = Assert.Throws<ArgumentException>(() => Dosc.Batch(source, output, 14, 5, 3, 9));
+        Assert.Equal("output", ex.ParamName);
+    }
+
+    [Fact]
+    public void SpanBatch_ZeroRsiPeriod_ThrowsArgumentOutOfRangeException()
+    {
+        double[] source = new double[10];
+        double[] output = new double[10];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Dosc.Batch(source, output, rsiPeriod: 0));
+    }
+
+    [Fact]
+    public void SpanBatch_ZeroSigPeriod_ThrowsArgumentOutOfRangeException()
+    {
+        double[] source = new double[10];
+        double[] output = new double[10];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Dosc.Batch(source, output, sigPeriod: 0));
+    }
+
+    [Fact]
+    public void SpanBatch_EmptyInput_ProducesNoException()
+    {
+        double[] source = Array.Empty<double>();
+        double[] output = Array.Empty<double>();
+        var ex = Record.Exception(() => Dosc.Batch(source, output, 14, 5, 3, 9));
+        Assert.Null(ex);
+    }
+
+    [Fact]
+    public void SpanBatch_LargeData_DoesNotStackOverflow()
+    {
+        int size = 5000;
+        double[] source = new double[size];
+        double[] output = new double[size];
+
+        for (int i = 0; i < size; i++)
+        {
+            source[i] = 100.0 + i * 0.1;
+        }
+
+        Dosc.Batch(source, output, 14, 5, 3, 9);
+        Assert.True(double.IsFinite(output[size - 1]));
+    }
+
+    // ========== H) Chainability ==========
+
+    [Fact]
+    public void Pub_EventFires_OnUpdate()
+    {
+        var indicator = new Dosc();
+        int eventCount = 0;
+
+        indicator.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
+
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
+        }
+
+        Assert.Equal(10, eventCount);
+    }
+
+    [Fact]
+    public void EventBased_Chaining_Works()
+    {
+        var source = new TSeries();
+        var indicator = new Dosc(source, 5, 3, 2, 4);
+
+        source.Add(new TValue(DateTime.UtcNow, 100));
+        source.Add(new TValue(DateTime.UtcNow, 110));
+        source.Add(new TValue(DateTime.UtcNow, 120));
+
+        Assert.True(double.IsFinite(indicator.Last.Value));
+    }
+
+    [Fact]
+    public void Calculate_ReturnsHotIndicator()
+    {
+        TSeries data = MakeSeries();
+        (TSeries results, Dosc indicator) = Dosc.Calculate(data);
+
+        Assert.Equal(data.Count, results.Count);
+        Assert.True(indicator.IsHot);
+    }
+
+    // ========== DOSC-specific: Oscillator behavior ==========
+
+    [Fact]
+    public void ConstantInput_OutputConvergesToZero()
+    {
+        // With all constant input, RSI is constant, EMA1 == EMA2 == constant,
+        // SMA signal converges to the same constant → DOSC → 0
+        var indicator = new Dosc(rsiPeriod: 5, ema1Period: 3, ema2Period: 2, sigPeriod: 5);
+        double lastResult = double.NaN;
+
+        for (int i = 0; i < 500; i++)
+        {
+            TValue r = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
+            lastResult = r.Value;
+        }
+
+        Assert.True(Math.Abs(lastResult) < 1e-6, $"Expected near-zero for constant input, got {lastResult}");
+    }
+
+    [Fact]
+    public void DoscProducesFiniteValues_OnGBMData()
+    {
+        var indicator = new Dosc();
+        TSeries data = MakeSeries(200);
+
+        int nonFiniteCount = 0;
+        for (int i = 0; i < data.Count; i++)
+        {
+            TValue r = indicator.Update(data[i]);
+            if (!double.IsFinite(r.Value))
+            {
+                nonFiniteCount++;
+            }
+        }
+
+        Assert.Equal(0, nonFiniteCount);
+    }
+}

lib/oscillators/dosc/tests/Dosc.Validation.Tests.cs

@@ -0,0 +1,174 @@
+using Xunit;
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public sealed class DoscValidationTests : IDisposable
+{
+    private readonly ITestOutputHelper _output;
+    private readonly ValidationTestData _testData;
+    private const int DefaultRsi = 14;
+    private const int DefaultEma1 = 5;
+    private const int DefaultEma2 = 3;
+    private const int DefaultSig = 9;
+
+    public DoscValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+        _testData = new ValidationTestData(10000);
+    }
+
+    public void Dispose()
+    {
+        _testData.Dispose();
+    }
+
+    // ========== Self-consistency Validation ==========
+
+    [Fact]
+    public void Dosc_BatchStreaming_Match()
+    {
+        var streaming = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+        var streamResults = new List<double>(_testData.Data.Count);
+        for (int i = 0; i < _testData.Data.Count; i++)
+        {
+            TValue r = streaming.Update(_testData.Data[i], isNew: true);
+            streamResults.Add(r.Value);
+        }
+
+        TSeries batchResults = Dosc.Batch(_testData.Data, DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+
+        int mismatchCount = 0;
+        double maxDiff = 0;
+        for (int i = 0; i < streamResults.Count; i++)
+        {
+            double diff = Math.Abs(streamResults[i] - batchResults[i].Value);
+            if (diff > 1e-10)
+            {
+                mismatchCount++;
+                maxDiff = Math.Max(maxDiff, diff);
+            }
+        }
+
+        _output.WriteLine($"Dosc({DefaultRsi},{DefaultEma1},{DefaultEma2},{DefaultSig}) Batch vs Streaming: {mismatchCount} mismatches, max diff = {maxDiff:E3}");
+        Assert.Equal(0, mismatchCount);
+    }
+
+    [Fact]
+    public void Dosc_SpanBatch_MatchesStreaming()
+    {
+        var streaming = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+        var streamResults = new List<double>(_testData.Data.Count);
+        for (int i = 0; i < _testData.Data.Count; i++)
+        {
+            TValue r = streaming.Update(_testData.Data[i], isNew: true);
+            streamResults.Add(r.Value);
+        }
+
+        double[] output = new double[_testData.Data.Count];
+        Dosc.Batch(_testData.Data.Values, output, DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+
+        int mismatchCount = 0;
+        double maxDiff = 0;
+        for (int i = 0; i < streamResults.Count; i++)
+        {
+            double diff = Math.Abs(streamResults[i] - output[i]);
+            if (diff > 1e-10)
+            {
+                mismatchCount++;
+                maxDiff = Math.Max(maxDiff, diff);
+            }
+        }
+
+        _output.WriteLine($"Dosc({DefaultRsi},{DefaultEma1},{DefaultEma2},{DefaultSig}) Span vs Streaming: {mismatchCount} mismatches, max diff = {maxDiff:E3}");
+        Assert.Equal(0, mismatchCount);
+    }
+
+    [Fact]
+    public void Dosc_DifferentParams_ProduceDifferentResults()
+    {
+        TSeries result1 = Dosc.Batch(_testData.Data, rsiPeriod: 7, ema1Period: 3, ema2Period: 2, sigPeriod: 5);
+        TSeries result2 = Dosc.Batch(_testData.Data, rsiPeriod: 14, ema1Period: 5, ema2Period: 3, sigPeriod: 9);
+
+        int lastIdx = _testData.Data.Count - 1;
+        _output.WriteLine($"Dosc(7,3,2,5) last = {result1[lastIdx].Value:F6}");
+        _output.WriteLine($"Dosc(14,5,3,9) last = {result2[lastIdx].Value:F6}");
+
+        Assert.NotEqual(result1[lastIdx].Value, result2[lastIdx].Value);
+    }
+
+    [Fact]
+    public void Dosc_ConstantInput_ConvergesToZero()
+    {
+        var indicator = new Dosc(rsiPeriod: 5, ema1Period: 3, ema2Period: 2, sigPeriod: 5);
+        double constantVal = 100.0;
+
+        double lastResult = double.NaN;
+        for (int i = 0; i < 1000; i++)
+        {
+            TValue r = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), constantVal));
+            lastResult = r.Value;
+        }
+
+        _output.WriteLine($"Dosc(5,3,2,5) constant input result after 1000 bars: {lastResult:E6}");
+        Assert.True(Math.Abs(lastResult) < 1e-6, $"Expected near-zero for constant input, got {lastResult}");
+    }
+
+    [Fact]
+    public void Dosc_Calculate_ReturnsHotIndicator()
+    {
+        (TSeries results, Dosc indicator) = Dosc.Calculate(_testData.Data, DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+
+        Assert.Equal(_testData.Data.Count, results.Count);
+        Assert.True(indicator.IsHot);
+
+        TValue next = indicator.Update(new TValue(DateTime.UtcNow, 100.0), isNew: true);
+        Assert.True(double.IsFinite(next.Value));
+
+        _output.WriteLine($"Dosc Calculate: {results.Count} bars, last = {results[results.Count - 1].Value:F6}");
+    }
+
+    [Fact]
+    public void Dosc_BarCorrection_ProducesConsistentResults()
+    {
+        var reference = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+        for (int i = 0; i < 100; i++)
+        {
+            reference.Update(_testData.Data[i], isNew: true);
+        }
+        reference.Update(new TValue(DateTime.UtcNow, 50.0), isNew: true);
+        double referenceVal = reference.Last.Value;
+
+        var test = new Dosc(DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+        for (int i = 0; i < 100; i++)
+        {
+            test.Update(_testData.Data[i], isNew: true);
+        }
+        test.Update(new TValue(DateTime.UtcNow, 999.0), isNew: true);  // wrong
+        test.Update(new TValue(DateTime.UtcNow, 50.0), isNew: false);  // correct
+        double testVal = test.Last.Value;
+
+        _output.WriteLine($"Reference: {referenceVal:F10}, Corrected: {testVal:F10}");
+        Assert.Equal(referenceVal, testVal, 1e-10);
+    }
+
+    [Fact]
+    public void Dosc_SubsetValidation_StableBehavior()
+    {
+        using var subset = _testData.CreateSubset(200);
+
+        TSeries results = Dosc.Batch(subset.Data, DefaultRsi, DefaultEma1, DefaultEma2, DefaultSig);
+
+        int nanCount = 0;
+        for (int i = 0; i < results.Count; i++)
+        {
+            if (!double.IsFinite(results[i].Value))
+            {
+                nanCount++;
+            }
+        }
+
+        _output.WriteLine($"Dosc on 200-bar subset: {nanCount} non-finite values");
+        Assert.Equal(0, nanCount);
+    }
+}