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/apo/tests/Apo.Quantower.Tests.cs

@@ -0,0 +1,121 @@
+using TradingPlatform.BusinessLayer;
+using QuanTAlib;
+
+namespace QuanTAlib.Tests;
+
+public class ApoIndicatorTests
+{
+    [Fact]
+    public void ApoIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new ApoIndicator();
+
+        Assert.Equal(12, indicator.FastPeriod);
+        Assert.Equal(26, indicator.SlowPeriod);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("APO - Absolute Price Oscillator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void ApoIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new ApoIndicator { SlowPeriod = 20 };
+
+        Assert.Equal(0, ApoIndicator.MinHistoryDepths);
+        IWatchlistIndicator watchlistIndicator = indicator;
+        Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ApoIndicator_ShortName_IncludesParameters()
+    {
+        var indicator = new ApoIndicator { FastPeriod = 10, SlowPeriod = 40 };
+        indicator.Initialize();
+
+        Assert.Contains("APO", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("10", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("40", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ApoIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new ApoIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Apo.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ApoIndicator_Initialize_CreatesInternalApo()
+    {
+        var indicator = new ApoIndicator { FastPeriod = 5, SlowPeriod = 34 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void ApoIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new ApoIndicator { FastPeriod = 2, SlowPeriod = 5 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        // Need enough bars for Period
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+
+            // Process update for each bar to simulate history loading
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Line series should have a value
+        double val = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(val));
+    }
+
+    [Fact]
+    public void ApoIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new ApoIndicator { FastPeriod = 2, SlowPeriod = 5 };
+        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);
+        }
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Add new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(20), 120, 130, 110, 125);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void ApoIndicator_Parameters_CanBeChanged()
+    {
+        var indicator = new ApoIndicator { FastPeriod = 5, SlowPeriod = 34 };
+        Assert.Equal(5, indicator.FastPeriod);
+        Assert.Equal(34, indicator.SlowPeriod);
+
+        indicator.FastPeriod = 10;
+        indicator.SlowPeriod = 40;
+
+        Assert.Equal(10, indicator.FastPeriod);
+        Assert.Equal(40, indicator.SlowPeriod);
+        Assert.Equal(0, ApoIndicator.MinHistoryDepths);
+    }
+}

lib/oscillators/apo/tests/Apo.Tests.cs

@@ -0,0 +1,273 @@
+
+namespace QuanTAlib;
+
+public class ApoTests
+{
+    [Fact]
+    public void BasicCalculation_DoesNotCrash()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            apo.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(apo.Last.Value));
+    }
+
+    [Fact]
+    public void IsNew_Consistency()
+    {
+        var apo = new Apo(12, 26);
+        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++)
+        {
+            apo.Update(bars[i]);
+        }
+
+        // Update with 100th point (isNew=true)
+        apo.Update(bars[99], true);
+
+        // Update with modified 100th point (isNew=false)
+        var modifiedBar = new TBar(bars[99].Time, bars[99].Open, bars[99].High + 1.0, bars[99].Low - 1.0, bars[99].Close, bars[99].Volume);
+        var val2 = apo.Update(modifiedBar, false);
+
+        // Create new instance and feed up to modified
+        var apo2 = new Apo(12, 26);
+        for (int i = 0; i < 99; i++)
+        {
+            apo2.Update(bars[i]);
+        }
+        var val3 = apo2.Update(modifiedBar, true);
+
+        Assert.Equal(val3.Value, val2.Value, 1e-9);
+    }
+
+    [Fact]
+    public void Reset_Works()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            apo.Update(bars[i]);
+        }
+
+        apo.Reset();
+        Assert.Equal(0, apo.Last.Value);
+        Assert.False(apo.IsHot);
+
+        // Feed again
+        for (int i = 0; i < bars.Count; i++)
+        {
+            apo.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(apo.Last.Value));
+    }
+
+    [Fact]
+    public void TBarSeries_Update_Matches_Streaming()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var streamingResults = new List<double>();
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamingResults.Add(apo.Update(bars[i]).Value);
+        }
+
+        var apo2 = new Apo(12, 26);
+        var seriesResults = apo2.Update(bars.Close);
+
+        Assert.Equal(streamingResults.Count, seriesResults.Count);
+        for (int i = 0; i < seriesResults.Count; i++)
+        {
+            Assert.Equal(streamingResults[i], seriesResults.Values[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void StaticCalculate_Matches_Streaming()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var apo = new Apo(12, 26);
+        var streamingResults = new List<double>();
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamingResults.Add(apo.Update(bars[i]).Value);
+        }
+
+        var staticResults = Apo.Batch(bars.Close, 12, 26);
+
+        Assert.Equal(streamingResults.Count, staticResults.Count);
+        for (int i = 0; i < staticResults.Count; i++)
+        {
+            Assert.Equal(streamingResults[i], staticResults.Values[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Chainability_Works()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(10, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Test TBarSeries chain
+        var result = apo.Update(bars.Close);
+        Assert.NotNull(result);
+        Assert.IsType<TSeries>(result);
+
+        // Test TBar chain (returns TValue)
+        var result2 = apo.Update(bars[0]);
+        Assert.IsType<TValue>(result2);
+    }
+
+    [Fact]
+    public void Constructor_InvalidParameters_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Apo(0, 26));
+        Assert.Throws<ArgumentException>(() => new Apo(12, 0));
+        Assert.Throws<ArgumentException>(() => new Apo(26, 12)); // Fast >= Slow
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreToOriginalState()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+
+        // Feed 50 new values (more than slow period)
+        TBar fiftiethInput = default;
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            fiftiethInput = bar;
+            apo.Update(bar, isNew: true);
+        }
+
+        // Remember state after 50 values
+        double stateAfterFifty = apo.Last.Value;
+
+        // Generate 9 corrections with isNew=false (different values)
+        for (int i = 0; i < 9; i++)
+        {
+            var bar = gbm.Next(isNew: false);
+            apo.Update(bar, isNew: false);
+        }
+
+        // Feed the remembered 50th input again with isNew=false
+        TValue finalResult = apo.Update(fiftiethInput, isNew: false);
+
+        // State should match the original state after 50 values
+        Assert.Equal(stateAfterFifty, finalResult.Value, 1e-10);
+    }
+
+    [Fact]
+    public void IsHot_BecomesTrueWhenBufferFull()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM();
+
+        Assert.False(apo.IsHot);
+
+        // Feed bars until IsHot becomes true
+        int count = 0;
+        while (!apo.IsHot && count < 100)
+        {
+            var bar = gbm.Next(isNew: true);
+            apo.Update(bar, isNew: true);
+            count++;
+        }
+
+        Assert.True(apo.IsHot);
+        Assert.True(count >= 26); // Should take at least slow period bars
+    }
+
+    [Fact]
+    public void NaN_Input_UsesLastValidValue()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed some valid bars first
+        for (int i = 0; i < 40; i++)
+        {
+            apo.Update(bars[i]);
+        }
+
+        // Create a bar with NaN close value
+        var nanBar = new TBar(DateTime.UtcNow, 100, 105, 95, double.NaN, 1000);
+        var result = apo.Update(nanBar);
+
+        // Should not crash and should return a finite value
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Infinity_Input_UsesLastValidValue()
+    {
+        var apo = new Apo(12, 26);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Feed some valid bars first
+        for (int i = 0; i < 40; i++)
+        {
+            apo.Update(bars[i]);
+        }
+
+        // Create a bar with Infinity close value
+        var infBar = new TBar(DateTime.UtcNow, 100, 105, 95, double.PositiveInfinity, 1000);
+        var result = apo.Update(infBar);
+
+        // Should not crash and should return a finite value
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void AllModes_ProduceSameResult()
+    {
+        // Arrange
+        const int fastPeriod = 12;
+        int slowPeriod = 26;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var closeSeries = bars.Close;
+
+        // 1. Batch Mode (static method)
+        var batchSeries = Apo.Batch(closeSeries, fastPeriod, slowPeriod);
+        double expected = batchSeries.Last.Value;
+
+        // 2. Streaming Mode (instance, one bar at a time)
+        var streamingInd = new Apo(fastPeriod, slowPeriod);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamingInd.Update(bars[i]);
+        }
+        double streamingResult = streamingInd.Last.Value;
+
+        // 3. Instance Update with TSeries
+        var instanceInd = new Apo(fastPeriod, slowPeriod);
+        var instanceResult = instanceInd.Update(closeSeries);
+        double instanceValue = instanceResult.Last.Value;
+
+        // Assert all modes produce identical results
+        Assert.Equal(expected, streamingResult, precision: 9);
+        Assert.Equal(expected, instanceValue, precision: 9);
+    }
+}

lib/oscillators/apo/tests/Apo.Validation.Tests.cs

@@ -0,0 +1,149 @@
+using QuanTAlib.Tests;
+using OoplesFinance.StockIndicators;
+using OoplesFinance.StockIndicators.Models;
+using OoplesFinance.StockIndicators.Enums;
+
+namespace QuanTAlib;
+
+public sealed class ApoValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private bool _disposed;
+
+    public ApoValidationTests()
+    {
+        _testData = new ValidationTestData(); // Default 5000 bars
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+
+        if (disposing)
+        {
+            _testData?.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Validate_Against_TALib_Apo()
+    {
+        const int fastPeriod = 12;
+        int slowPeriod = 26;
+        double[] input = _testData.Data.Values.ToArray();
+        double[] output = new double[input.Length];
+
+        // TA-Lib APO: double[] inReal, int optInFastPeriod, int optInSlowPeriod, int optInTALib.Core.MAType
+        // TALib.Core.MAType 1 = EMA
+        var retCode = TALib.Functions.Apo<double>(input, 0..^0, output, out var outRange, fastPeriod, slowPeriod, TALib.Core.MAType.Ema);
+        Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+        // 1. Batch Mode
+        var apo = new Apo(fastPeriod, slowPeriod);
+        var result = apo.Update(_testData.Data);
+        ValidationHelper.VerifyData(result, output, outRange, lookback: slowPeriod - 1);
+
+        // 2. Streaming Mode
+        var apoStream = new Apo(fastPeriod, slowPeriod);
+        var streamResults = new List<double>();
+        foreach (var item in _testData.Data)
+        {
+            streamResults.Add(apoStream.Update(item).Value);
+        }
+        ValidationHelper.VerifyData(streamResults, output, outRange, lookback: slowPeriod - 1);
+
+        // 3. Span Mode
+        double[] spanOutput = new double[input.Length];
+        Apo.Batch(input.AsSpan(), spanOutput.AsSpan(), fastPeriod, slowPeriod);
+        ValidationHelper.VerifyData(spanOutput, output, outRange, lookback: slowPeriod - 1);
+    }
+
+    [Fact]
+    public void Validate_Against_Tulip_Apo()
+    {
+        // Tulip APO uses standard EMA initialization (first value), while QuanTAlib uses
+        // compensated EMA initialization (zero-based). They converge after sufficient periods.
+        // With 5000 bars, the tail (last 100) should match closely.
+        int fastPeriod = 12;
+        int slowPeriod = 26;
+        double[] input = _testData.Data.Values.ToArray();
+
+        var apoIndicator = Tulip.Indicators.apo;
+        double[][] inputs = { input };
+        double[] options = { fastPeriod, slowPeriod };
+        double[][] outputs = { new double[input.Length - 1] }; // Tulip APO starts at 1
+
+        apoIndicator.Run(inputs, options, outputs);
+        double[] output = outputs[0];
+
+        // 1. Batch Mode
+        var apo = new Apo(fastPeriod, slowPeriod);
+        var result = apo.Update(_testData.Data);
+        ValidationHelper.VerifyData(result, output, lookback: 1);
+
+        // 2. Streaming Mode
+        var apoStream = new Apo(fastPeriod, slowPeriod);
+        var streamResults = new List<double>();
+        foreach (var item in _testData.Data)
+        {
+            streamResults.Add(apoStream.Update(item).Value);
+        }
+        ValidationHelper.VerifyData(streamResults, output, lookback: 1);
+
+        // 3. Span Mode
+        double[] spanOutput = new double[input.Length];
+        Apo.Batch(input.AsSpan(), spanOutput.AsSpan(), fastPeriod, slowPeriod);
+        ValidationHelper.VerifyData(spanOutput, output, lookback: 1);
+    }
+
+    [Fact]
+    public void Validate_Against_Ooples_Apo()
+    {
+        int fastPeriod = 12;
+        int slowPeriod = 26;
+
+        var ooplesData = _testData.SkenderQuotes.Select(q => new TickerData
+        {
+            Date = q.Date,
+            Open = (double)q.Open,
+            High = (double)q.High,
+            Low = (double)q.Low,
+            Close = (double)q.Close,
+            Volume = (double)q.Volume
+        }).ToList();
+
+        var stockData = new StockData(ooplesData);
+        var results = stockData.CalculateAbsolutePriceOscillator(MovingAvgType.ExponentialMovingAverage, fastPeriod, slowPeriod);
+        var output = results.OutputValues["Apo"].ToArray();
+
+        // 1. Batch Mode
+        var apo = new Apo(fastPeriod, slowPeriod);
+        var result = apo.Update(_testData.Data);
+        ValidationHelper.VerifyData(result, output, lookback: 0, tolerance: ValidationHelper.OoplesTolerance);
+
+        // 2. Streaming Mode
+        var apoStream = new Apo(fastPeriod, slowPeriod);
+        var streamResults = new List<double>();
+        foreach (var item in _testData.Data)
+        {
+            streamResults.Add(apoStream.Update(item).Value);
+        }
+        ValidationHelper.VerifyData(streamResults, output, lookback: 0, tolerance: ValidationHelper.OoplesTolerance);
+
+        // 3. Span Mode
+        double[] input = _testData.Data.Values.ToArray();
+        double[] spanOutput = new double[input.Length];
+        Apo.Batch(input.AsSpan(), spanOutput.AsSpan(), fastPeriod, slowPeriod);
+        ValidationHelper.VerifyData(spanOutput, output, lookback: 0, tolerance: ValidationHelper.OoplesTolerance);
+    }
+}