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/trends_IIR/lema/tests/Lema.Quantower.Tests.cs

@@ -0,0 +1,154 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class LemaIndicatorTests
+{
+    [Fact]
+    public void LemaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new LemaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("LEMA - Leader Exponential Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void LemaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new LemaIndicator { Period = 20 };
+
+        Assert.Equal(0, LemaIndicator.MinHistoryDepths);
+        Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void LemaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new LemaIndicator { Period = 15 };
+
+        Assert.Contains("LEMA", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("15", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void LemaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new LemaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Lema.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void LemaIndicator_Initialize_CreatesInternalLema()
+    {
+        var indicator = new LemaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void LemaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new LemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void LemaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new LemaIndicator { Period = 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 LemaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new LemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void LemaIndicator_MultipleUpdates_ProducesCorrectLemaSequence()
+    {
+        var indicator = new LemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+    }
+
+    [Fact]
+    public void LemaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new LemaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+}

lib/trends_IIR/lema/tests/Lema.Tests.cs

@@ -0,0 +1,329 @@
+namespace QuanTAlib.Tests;
+
+public class LemaTests
+{
+    [Fact]
+    public void Lema_Matches_ManualCalculation()
+    {
+        // Arrange
+        const int period = 10;
+        var lema = new Lema(period);
+        var ema1 = new Ema(period);
+        var ema2 = new Ema(period);
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+
+        // Act & Assert
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            var tVal = new TValue(bar.Time, bar.Close);
+
+            var lVal = lema.Update(tVal);
+
+            var e1Val = ema1.Update(tVal);
+            double error = tVal.Value - e1Val.Value;
+            var e2Val = ema2.Update(new TValue(tVal.Time, error));
+            double expected = e1Val.Value + e2Val.Value;
+
+            Assert.Equal(expected, lVal.Value, 1e-9);
+        }
+    }
+
+    [Fact]
+    public void StaticCalculate_Matches_ObjectUpdate()
+    {
+        // Arrange
+        const int period = 10;
+        var source = new TSeries();
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            source.Add(new TValue(bar.Time, bar.Close));
+        }
+
+        // Act
+        var lemaSeries = Lema.Batch(source, period);
+        var lemaObj = new Lema(period);
+
+        // Assert
+        for (int i = 0; i < source.Count; i++)
+        {
+            var val = lemaObj.Update(source[i]);
+            Assert.Equal(val.Value, lemaSeries[i].Value, 1e-9);
+        }
+    }
+
+    [Fact]
+    public void ZeroAllocCalculate_Matches_ObjectUpdate()
+    {
+        // Arrange
+        const int period = 10;
+        const int count = 100;
+        var source = new double[count];
+        var output = new double[count];
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        for (int i = 0; i < count; i++)
+        {
+            source[i] = gbm.Next().Close;
+        }
+
+        // Act
+        Lema.Batch(source, output, period);
+        var lemaObj = new Lema(period);
+
+        // Assert
+        for (int i = 0; i < count; i++)
+        {
+            var val = lemaObj.Update(new TValue(DateTime.UtcNow, source[i]));
+            Assert.Equal(val.Value, output[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Alpha_Constructor_Matches_Period_Constructor()
+    {
+        // Arrange
+        const int period = 10;
+        double alpha = 2.0 / (period + 1);
+        var lemaPeriod = new Lema(period);
+        var lemaAlpha = new Lema(alpha);
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+
+        // Act & Assert
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            var tVal = new TValue(bar.Time, bar.Close);
+
+            var pVal = lemaPeriod.Update(tVal);
+            var aVal = lemaAlpha.Update(tVal);
+
+            Assert.Equal(pVal.Value, aVal.Value, 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Alpha_Constructor_Sets_WarmupPeriod()
+    {
+        const int period = 10;
+        double alpha = 2.0 / (period + 1);
+        var lema = new Lema(alpha);
+        Assert.Equal(period, lema.WarmupPeriod);
+    }
+
+    [Fact]
+    public void StaticCalculate_Alpha_Matches_ObjectUpdate()
+    {
+        // Arrange
+        const double alpha = 0.15;
+        var source = new TSeries();
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        for (int i = 0; i < 100; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            source.Add(new TValue(bar.Time, bar.Close));
+        }
+
+        // Act
+        var lemaSeries = Lema.Batch(source, alpha);
+        var lemaObj = new Lema(alpha);
+
+        // Assert
+        for (int i = 0; i < source.Count; i++)
+        {
+            var val = lemaObj.Update(source[i]);
+            Assert.Equal(val.Value, lemaSeries[i].Value, 1e-9);
+        }
+    }
+
+    [Fact]
+    public void ZeroAllocCalculate_Alpha_Matches_ObjectUpdate()
+    {
+        // Arrange
+        const double alpha = 0.15;
+        const int count = 100;
+        var source = new double[count];
+        var output = new double[count];
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        for (int i = 0; i < count; i++)
+        {
+            source[i] = gbm.Next().Close;
+        }
+
+        // Act
+        Lema.Batch(source, output, alpha);
+        var lemaObj = new Lema(alpha);
+
+        // Assert
+        for (int i = 0; i < count; i++)
+        {
+            var val = lemaObj.Update(new TValue(DateTime.UtcNow, source[i]));
+            Assert.Equal(val.Value, output[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Lema_Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentException>(() => new Lema(0));
+        Assert.Throws<ArgumentException>(() => new Lema(-1));
+        Assert.Throws<ArgumentException>(() => new Lema(0.0));
+        Assert.Throws<ArgumentException>(() => new Lema(1.1));
+    }
+
+    [Fact]
+    public void Lema_Calc_IsNew_AcceptsParameter()
+    {
+        var lema = new Lema(10);
+        lema.Update(new TValue(DateTime.UtcNow, 100), isNew: true);
+        Assert.Equal(100, lema.Last.Value);
+    }
+
+    [Fact]
+    public void Lema_Reset_ClearsState()
+    {
+        var lema = new Lema(10);
+        lema.Update(new TValue(DateTime.UtcNow, 100));
+        lema.Update(new TValue(DateTime.UtcNow, 110));
+
+        lema.Reset();
+
+        Assert.Equal(0, lema.Last.Value);
+        Assert.False(lema.IsHot);
+    }
+
+    [Fact]
+    public void Lema_IterativeCorrections_RestoreToOriginalState()
+    {
+        var lema = new Lema(10);
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1);
+
+        // Feed 10 new values
+        TValue tenthInput = default;
+        for (int i = 0; i < 10; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            tenthInput = new TValue(bar.Time, bar.Close);
+            lema.Update(tenthInput, isNew: true);
+        }
+
+        // Remember state after 10 values
+        double valueAfterTen = lema.Last.Value;
+
+        // Generate 9 corrections with isNew=false (different values)
+        for (int i = 0; i < 9; i++)
+        {
+            var bar = gbm.Next(isNew: false);
+            lema.Update(new TValue(bar.Time, bar.Close), isNew: false);
+        }
+
+        // Feed the remembered 10th input again with isNew=false
+        TValue finalValue = lema.Update(tenthInput, isNew: false);
+
+        // Should match the original state after 10 values
+        Assert.Equal(valueAfterTen, finalValue.Value, 1e-9);
+    }
+
+    [Fact]
+    public void Lema_NaN_Input_UsesLastValidValue()
+    {
+        var lema = new Lema(10);
+        lema.Update(new TValue(DateTime.UtcNow, 100));
+        lema.Update(new TValue(DateTime.UtcNow, 110));
+
+        var resultAfterNaN = lema.Update(new TValue(DateTime.UtcNow, double.NaN));
+
+        Assert.True(double.IsFinite(resultAfterNaN.Value));
+        Assert.NotEqual(0, resultAfterNaN.Value);
+    }
+
+    [Fact]
+    public void Lema_SpanCalc_ValidatesInput()
+    {
+        double[] source = [1, 2, 3, 4, 5];
+        double[] output = new double[5];
+        double[] wrongSizeOutput = new double[3];
+
+        Assert.Throws<ArgumentException>(() => Lema.Batch(source.AsSpan(), output.AsSpan(), 0));
+        Assert.Throws<ArgumentException>(() => Lema.Batch(source.AsSpan(), wrongSizeOutput.AsSpan(), 3));
+    }
+
+    [Fact]
+    public void Lema_SpanCalc_HandlesNaN()
+    {
+        double[] source = [100, 110, double.NaN, 120, 130];
+        double[] output = new double[5];
+
+        Lema.Batch(source.AsSpan(), output.AsSpan(), 3);
+
+        foreach (var val in output)
+        {
+            Assert.True(double.IsFinite(val));
+        }
+    }
+
+    [Fact]
+    public void Lema_AllModes_ProduceSameResult()
+    {
+        // Arrange
+        const int period = 10;
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // 1. Batch Mode
+        var batchSeries = Lema.Batch(series, period);
+        double expected = batchSeries.Last.Value;
+
+        // 2. Span Mode
+        var tValues = series.Values.ToArray();
+        var spanInput = new ReadOnlySpan<double>(tValues);
+        var spanOutput = new double[tValues.Length];
+        Lema.Batch(spanInput, spanOutput, period);
+        double spanResult = spanOutput[^1];
+
+        // 3. Streaming Mode
+        var streamingInd = new Lema(period);
+        for (int i = 0; i < series.Count; i++)
+        {
+            streamingInd.Update(series[i]);
+        }
+        double streamingResult = streamingInd.Last.Value;
+
+        // 4. Eventing Mode
+        var pubSource = new TSeries();
+        var eventingInd = new Lema(pubSource, period);
+        for (int i = 0; i < series.Count; i++)
+        {
+            pubSource.Add(series[i]);
+        }
+        double eventingResult = eventingInd.Last.Value;
+
+        // Assert
+        Assert.Equal(expected, spanResult, precision: 9);
+        Assert.Equal(expected, streamingResult, precision: 9);
+        Assert.Equal(expected, eventingResult, precision: 9);
+    }
+
+    [Fact]
+    public void StaticCalculate_HandlesInitialNaN_Correctly()
+    {
+        double[] source = { double.NaN, double.NaN, 10.0, 11.0, 12.0 };
+        double[] output = new double[source.Length];
+
+        Lema.Batch(source, output, 3);
+
+        // We expect the first two outputs to be NaN because the input was NaN
+        Assert.True(double.IsNaN(output[0]), $"Output[0] should be NaN, but was {output[0]}");
+        Assert.True(double.IsNaN(output[1]), $"Output[1] should be NaN, but was {output[1]}");
+
+        // The first valid value is 10.0.
+        Assert.Equal(10.0, output[2], 1e-9);
+    }
+}

lib/trends_IIR/lema/tests/Lema.Validation.Tests.cs

@@ -0,0 +1,212 @@
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public sealed class LemaValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public LemaValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+        _testData = new ValidationTestData();
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+
+        if (disposing)
+        {
+            _testData?.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Validate_ManualEmaComposition_Batch()
+    {
+        // LEMA = EMA(source) + EMA(source - EMA(source))
+        // Validate batch mode against manual two-EMA composition
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        foreach (var period in periods)
+        {
+            var lema = new Lema(period);
+            var qResult = lema.Update(_testData.Data);
+
+            // Manual composition
+            var ema1 = new Ema(period);
+            var ema2 = new Ema(period);
+            var manualResults = new List<double>();
+
+            for (int i = 0; i < _testData.Data.Count; i++)
+            {
+                var item = _testData.Data[i];
+                var e1 = ema1.Update(item);
+                double error = item.Value - e1.Value;
+                var e2 = ema2.Update(new TValue(item.Time, error));
+                manualResults.Add(e1.Value + e2.Value);
+            }
+
+            // Compare all records
+            for (int i = 0; i < qResult.Count; i++)
+            {
+                Assert.Equal(manualResults[i], qResult[i].Value, 1e-9);
+            }
+        }
+        _output.WriteLine("LEMA Batch(TSeries) validated successfully against manual EMA composition");
+    }
+
+    [Fact]
+    public void Validate_StreamingVsBatch_Consistency()
+    {
+        // Streaming mode must match batch mode exactly
+        int[] periods = { 5, 10, 20, 50 };
+
+        foreach (var period in periods)
+        {
+            // Batch
+            var batchResult = Lema.Batch(_testData.Data, period);
+
+            // Streaming
+            var streaming = new Lema(period);
+            for (int i = 0; i < _testData.Data.Count; i++)
+            {
+                streaming.Update(_testData.Data[i]);
+            }
+
+            // Compare last 100 records
+            int start = Math.Max(0, _testData.Data.Count - 100);
+            for (int i = start; i < _testData.Data.Count; i++)
+            {
+                Assert.Equal(batchResult[i].Value, batchResult[i].Value, 1e-9);
+            }
+        }
+        _output.WriteLine("LEMA Streaming vs Batch validated successfully");
+    }
+
+    [Fact]
+    public void Validate_SpanVsStreaming_Consistency()
+    {
+        // Span API must match streaming exactly
+        int[] periods = { 5, 10, 20, 50 };
+        double[] sourceData = _testData.RawData.ToArray();
+
+        foreach (var period in periods)
+        {
+            // Span
+            double[] spanOutput = new double[sourceData.Length];
+            Lema.Batch(sourceData.AsSpan(), spanOutput.AsSpan(), period);
+
+            // Streaming
+            var streaming = new Lema(period);
+            for (int i = 0; i < sourceData.Length; i++)
+            {
+                var val = streaming.Update(new TValue(DateTime.UtcNow, sourceData[i]));
+                Assert.Equal(val.Value, spanOutput[i], 1e-9);
+            }
+        }
+        _output.WriteLine("LEMA Span vs Streaming validated successfully");
+    }
+
+    [Fact]
+    public void Validate_ConstantInput_ConvergesToInput()
+    {
+        // LEMA of constant series should converge to the constant value
+        // Since error = source - EMA(source) → 0, and EMA(0) → 0,
+        // LEMA → EMA(source) + 0 = source (at convergence)
+        const double constantValue = 42.0;
+        const int period = 10;
+
+        var lema = new Lema(period);
+        double lastResult = 0;
+
+        for (int i = 0; i < 200; i++)
+        {
+            var result = lema.Update(new TValue(DateTime.UtcNow, constantValue));
+            lastResult = result.Value;
+        }
+
+        // After enough iterations, LEMA should converge to the constant
+        Assert.Equal(constantValue, lastResult, 1e-6);
+        _output.WriteLine("LEMA constant input convergence validated successfully");
+    }
+
+    [Fact]
+    public void Validate_Against_ManualFormula()
+    {
+        // Validate against the explicit LEMA formula:
+        // LEMA = EMA(source, N) + EMA(source - EMA(source, N), N)
+        // Using our own Ema class as reference (Ooples-equivalent validation)
+
+        int[] periods = { 5, 10, 14, 20 };
+
+        foreach (var period in periods)
+        {
+            var lema = new Lema(period);
+            var ema1 = new Ema(period);
+            var ema2 = new Ema(period);
+
+            for (int i = 0; i < _testData.Data.Count; i++)
+            {
+                var item = _testData.Data[i];
+
+                // QuanTAlib LEMA
+                var qVal = lema.Update(item);
+
+                // Manual LEMA formula
+                var e1 = ema1.Update(item);
+                double error = item.Value - e1.Value;
+                var e2 = ema2.Update(new TValue(item.Time, error));
+                double manualVal = e1.Value + e2.Value;
+
+                Assert.Equal(manualVal, qVal.Value, ValidationHelper.DefaultTolerance);
+            }
+        }
+        _output.WriteLine("LEMA validated successfully against manual formula (EMA + EMA(error))");
+    }
+
+    [Fact]
+    public void Validate_NaN_Robustness()
+    {
+        // Feed data with interspersed NaN values and verify output stays finite
+        const int period = 10;
+        var lema = new Lema(period);
+
+        // Feed some valid values first to establish state
+        for (int i = 0; i < 20; i++)
+        {
+            lema.Update(new TValue(DateTime.UtcNow, 100.0 + i));
+        }
+
+        // Feed NaN
+        var nanResult = lema.Update(new TValue(DateTime.UtcNow, double.NaN));
+        Assert.True(double.IsFinite(nanResult.Value), "LEMA should handle NaN with last-valid substitution");
+
+        // Feed Infinity
+        var infResult = lema.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity));
+        Assert.True(double.IsFinite(infResult.Value), "LEMA should handle Infinity with last-valid substitution");
+
+        // Feed negative Infinity
+        var negInfResult = lema.Update(new TValue(DateTime.UtcNow, double.NegativeInfinity));
+        Assert.True(double.IsFinite(negInfResult.Value), "LEMA should handle -Infinity with last-valid substitution");
+
+        // Resume with valid value
+        var resumeResult = lema.Update(new TValue(DateTime.UtcNow, 125.0));
+        Assert.True(double.IsFinite(resumeResult.Value), "LEMA should resume cleanly after invalid inputs");
+
+        _output.WriteLine("LEMA NaN/Infinity robustness validated successfully");
+    }
+}