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/ao/tests/Ao.Quantower.Tests.cs

@@ -0,0 +1,124 @@
+using TradingPlatform.BusinessLayer;
+using QuanTAlib;
+
+namespace QuanTAlib.Tests;
+
+public class AoIndicatorTests
+{
+    [Fact]
+    public void AoIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new AoIndicator();
+
+        Assert.Equal(5, indicator.FastPeriod);
+        Assert.Equal(34, indicator.SlowPeriod);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("AO - Awesome Oscillator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void AoIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new AoIndicator { SlowPeriod = 20 };
+
+        Assert.Equal(0, AoIndicator.MinHistoryDepths);
+        IWatchlistIndicator watchlistIndicator = indicator;
+        Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void AoIndicator_ShortName_IncludesParameters()
+    {
+        var indicator = new AoIndicator { FastPeriod = 10, SlowPeriod = 40 };
+        indicator.Initialize();
+
+        Assert.Contains("AO", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("10", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("40", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AoIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new AoIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Ao.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AoIndicator_Initialize_CreatesInternalAo()
+    {
+        var indicator = new AoIndicator { FastPeriod = 5, SlowPeriod = 34 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist (Up and Down)
+        Assert.Equal(2, indicator.LinesSeries.Count);
+    }
+
+    [Fact]
+    public void AoIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new AoIndicator { 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 (either Up or Down)
+        // One should be NaN, other should be value, or both NaN if cold
+        double up = indicator.LinesSeries[0].GetValue(0);
+        double down = indicator.LinesSeries[1].GetValue(0);
+
+        Assert.True(double.IsFinite(up) || double.IsFinite(down));
+    }
+
+    [Fact]
+    public void AoIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new AoIndicator { 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 AoIndicator_Parameters_CanBeChanged()
+    {
+        var indicator = new AoIndicator { 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, AoIndicator.MinHistoryDepths);
+    }
+}

lib/oscillators/ao/tests/Ao.Tests.cs

@@ -0,0 +1,272 @@
+
+namespace QuanTAlib;
+
+public class AoTests
+{
+    [Fact]
+    public void BasicCalculation_DoesNotCrash()
+    {
+        var ao = new Ao(5, 34);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ao.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(ao.Last.Value));
+    }
+
+    [Fact]
+    public void IsNew_Consistency()
+    {
+        var ao = new Ao(5, 34);
+        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++)
+        {
+            ao.Update(bars[i]);
+        }
+
+        // Update with 100th point (isNew=true)
+        ao.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 = ao.Update(modifiedBar, false);
+
+        // Create new instance and feed up to modified
+        var ao2 = new Ao(5, 34);
+        for (int i = 0; i < 99; i++)
+        {
+            ao2.Update(bars[i]);
+        }
+        var val3 = ao2.Update(modifiedBar, true);
+
+        Assert.Equal(val3.Value, val2.Value, 1e-9);
+    }
+
+    [Fact]
+    public void Reset_Works()
+    {
+        var ao = new Ao(5, 34);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ao.Update(bars[i]);
+        }
+
+        ao.Reset();
+        Assert.Equal(0, ao.Last.Value);
+        Assert.False(ao.IsHot);
+
+        // Feed again
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ao.Update(bars[i]);
+        }
+
+        Assert.True(double.IsFinite(ao.Last.Value));
+    }
+
+    [Fact]
+    public void TBarSeries_Update_Matches_Streaming()
+    {
+        var ao = new Ao(5, 34);
+        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(ao.Update(bars[i]).Value);
+        }
+
+        var ao2 = new Ao(5, 34);
+        var seriesResults = ao2.Update(bars);
+
+        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 ao = new Ao(5, 34);
+        var streamingResults = new List<double>();
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamingResults.Add(ao.Update(bars[i]).Value);
+        }
+
+        var staticResults = Ao.Batch(bars, 5, 34);
+
+        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 ao = new Ao(5, 34);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(10, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Test TBarSeries chain
+        var result = ao.Update(bars);
+        Assert.NotNull(result);
+        Assert.IsType<TSeries>(result);
+
+        // Test TBar chain (returns TValue)
+        var result2 = ao.Update(bars[0]);
+        Assert.IsType<TValue>(result2);
+    }
+
+    [Fact]
+    public void Constructor_InvalidParameters_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Ao(0, 34));
+        Assert.Throws<ArgumentException>(() => new Ao(5, 0));
+        Assert.Throws<ArgumentException>(() => new Ao(34, 5)); // Fast >= Slow
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreToOriginalState()
+    {
+        var ao = new Ao(5, 34);
+        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;
+            ao.Update(bar, isNew: true);
+        }
+
+        // Remember state after 50 values
+        double stateAfterFifty = ao.Last.Value;
+
+        // Generate 9 corrections with isNew=false (different values)
+        for (int i = 0; i < 9; i++)
+        {
+            var bar = gbm.Next(isNew: false);
+            ao.Update(bar, isNew: false);
+        }
+
+        // Feed the remembered 50th input again with isNew=false
+        TValue finalResult = ao.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 ao = new Ao(5, 34);
+        var gbm = new GBM();
+
+        Assert.False(ao.IsHot);
+
+        // Feed bars until IsHot becomes true
+        int count = 0;
+        while (!ao.IsHot && count < 100)
+        {
+            var bar = gbm.Next(isNew: true);
+            ao.Update(bar, isNew: true);
+            count++;
+        }
+
+        Assert.True(ao.IsHot);
+        Assert.True(count >= 34); // Should take at least slow period bars
+    }
+
+    [Fact]
+    public void NaN_Input_UsesLastValidValue()
+    {
+        var ao = new Ao(5, 34);
+        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++)
+        {
+            ao.Update(bars[i]);
+        }
+
+        // Create a bar with NaN values
+        var nanBar = new TBar(DateTime.UtcNow, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN);
+        var result = ao.Update(nanBar);
+
+        // Should not crash and should return a finite value
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Infinity_Input_UsesLastValidValue()
+    {
+        var ao = new Ao(5, 34);
+        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++)
+        {
+            ao.Update(bars[i]);
+        }
+
+        // Create a bar with Infinity values
+        var infBar = new TBar(DateTime.UtcNow, double.PositiveInfinity, double.PositiveInfinity, double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity);
+        var result = ao.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 = 5;
+        int slowPeriod = 34;
+        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));
+
+        // 1. Batch Mode (static method)
+        var batchSeries = Ao.Batch(bars, fastPeriod, slowPeriod);
+        double expected = batchSeries.Last.Value;
+
+        // 2. Streaming Mode (instance, one bar at a time)
+        var streamingInd = new Ao(fastPeriod, slowPeriod);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            streamingInd.Update(bars[i]);
+        }
+        double streamingResult = streamingInd.Last.Value;
+
+        // 3. Instance Update with TBarSeries
+        var instanceInd = new Ao(fastPeriod, slowPeriod);
+        var instanceResult = instanceInd.Update(bars);
+        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/ao/tests/Ao.Validation.Tests.cs

@@ -0,0 +1,120 @@
+using Skender.Stock.Indicators;
+using OoplesFinance.StockIndicators;
+using OoplesFinance.StockIndicators.Models;
+using QuanTAlib.Tests;
+
+namespace QuanTAlib;
+
+public sealed class AoValidationTests : IDisposable
+{
+    private readonly ValidationTestData _data;
+
+    public AoValidationTests()
+    {
+        _data = new ValidationTestData();
+    }
+
+    public void Dispose()
+    {
+        _data.Dispose();
+    }
+
+    [Fact]
+    public void MatchesSkender()
+    {
+        var ao = new Ao(5, 34);
+        var results = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            var res = ao.Update(_data.Bars[i]);
+            results.Add(res.Value);
+        }
+
+        var skenderResults = _data.SkenderQuotes.GetAwesome(5, 34).ToList();
+
+        Assert.Equal(_data.Bars.Count, skenderResults.Count);
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            // Skender returns null for warmup
+            if (skenderResults[i].Oscillator == null)
+            {
+                continue;
+            }
+
+            Assert.Equal((double)skenderResults[i].Oscillator!, results[i], ValidationHelper.SkenderTolerance);
+        }
+    }
+
+    [Fact]
+    public void MatchesTulip()
+    {
+        var ao = new Ao(5, 34);
+        var results = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            var res = ao.Update(_data.Bars[i]);
+            results.Add(res.Value);
+        }
+
+        var high = _data.Bars.High.Select(x => x.Value).ToArray();
+        var low = _data.Bars.Low.Select(x => x.Value).ToArray();
+
+        var tulipIndicator = Tulip.Indicators.ao;
+        double[][] inputs = { high, low };
+        double[] options = Array.Empty<double>();
+
+        const int lookback = 33;
+        double[][] outputs = [new double[_data.Bars.Count - lookback]];
+
+        tulipIndicator.Run(inputs, options, outputs);
+        var tulipResults = outputs[0];
+
+        for (int i = 0; i < tulipResults.Length; i++)
+        {
+            Assert.Equal(tulipResults[i], results[i + lookback], ValidationHelper.TulipTolerance);
+        }
+    }
+
+    [Fact]
+    public void MatchesOoples()
+    {
+        var ao = new Ao(5, 34);
+        var results = new List<double>();
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            var res = ao.Update(_data.Bars[i]);
+            results.Add(res.Value);
+        }
+
+        var ooplesData = _data.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 oResult = stockData.CalculateAwesomeOscillator(fastLength: 5, slowLength: 34);
+        var oValues = oResult.OutputValues["Ao"];
+
+        Assert.Equal(_data.Bars.Count, oValues.Count);
+
+        for (int i = 0; i < _data.Bars.Count; i++)
+        {
+            // Ooples might return 0 for warmup
+            if (i < 33)
+            {
+                continue; // Skip warmup
+            }
+
+            Assert.Equal(oValues[i], results[i], ValidationHelper.OoplesTolerance);
+        }
+    }
+}