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/tema/tests/Tema.Quantower.Tests.cs

@@ -0,0 +1,171 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class TemaIndicatorTests
+{
+    [Fact]
+    public void TemaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new TemaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("TEMA - Triple Exponential Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void TemaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new TemaIndicator { Period = 20 };
+
+        Assert.Equal(0, TemaIndicator.MinHistoryDepths);
+        Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void TemaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new TemaIndicator { Period = 15 };
+
+        Assert.Contains("TEMA", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("15", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TemaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new TemaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Tema.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TemaIndicator_Initialize_CreatesInternalTema()
+    {
+        var indicator = new TemaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void TemaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new TemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 102);
+
+            // Process update
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Line series should have a value
+        Assert.True(indicator.LinesSeries[0].Count > 0);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void TemaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new TemaIndicator { 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 TemaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new TemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 50; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 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 TemaIndicator_MultipleUpdates_ProducesCorrectTemaSequence()
+    {
+        var indicator = new TemaIndicator { 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 TemaIndicator_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 TemaIndicator { 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");
+        }
+    }
+
+    [Fact]
+    public void TemaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new TemaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(0, TemaIndicator.MinHistoryDepths);
+    }
+}

lib/trends_IIR/tema/tests/Tema.Tests.cs

@@ -0,0 +1,172 @@
+
+namespace QuanTAlib.Tests;
+
+public class TemaTests
+{
+    [Fact]
+    public void BasicCalculation_DoesNotCrash()
+    {
+        var tema = new Tema(10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            tema.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+
+        Assert.True(double.IsFinite(tema.Last.Value));
+    }
+
+    [Fact]
+    public void IsNew_Consistency()
+    {
+        var tema = new Tema(10);
+        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++)
+        {
+            tema.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+
+        // Update with 100th point (isNew=true)
+        tema.Update(new TValue(bars[99].Time, bars[99].Close), true);
+
+        // Update with modified 100th point (isNew=false)
+        var val2 = tema.Update(new TValue(bars[99].Time, bars[99].Close + 1.0), false);
+
+        // Create new instance and feed up to modified
+        var tema2 = new Tema(10);
+        for (int i = 0; i < 99; i++)
+        {
+            tema2.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+        var val3 = tema2.Update(new TValue(bars[99].Time, bars[99].Close + 1.0), true);
+
+        Assert.Equal(val3.Value, val2.Value, 1e-9);
+    }
+
+    [Fact]
+    public void Reset_Works()
+    {
+        var tema = new Tema(10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            tema.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+
+        tema.Reset();
+        Assert.Equal(0, tema.Last.Value);
+        Assert.False(tema.IsHot);
+
+        // Feed again
+        for (int i = 0; i < bars.Count; i++)
+        {
+            tema.Update(new TValue(bars[i].Time, bars[i].Close));
+        }
+
+        Assert.True(double.IsFinite(tema.Last.Value));
+    }
+
+    [Fact]
+    public void TSeries_Update_Matches_Streaming()
+    {
+        var tema = new Tema(10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        var streamingResults = new List<double>();
+        for (int i = 0; i < series.Count; i++)
+        {
+            streamingResults.Add(tema.Update(series[i]).Value);
+        }
+
+        var tema2 = new Tema(10);
+        var seriesResults = tema2.Update(series);
+
+        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 BatchCalculate_Matches_Streaming()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        var tema = new Tema(10);
+        var streamingResults = new List<double>();
+        for (int i = 0; i < series.Count; i++)
+        {
+            streamingResults.Add(tema.Update(series[i]).Value);
+        }
+
+        var batchResults = Tema.Batch(series, 10);
+
+        Assert.Equal(streamingResults.Count, batchResults.Count);
+        for (int i = 0; i < batchResults.Count; i++)
+        {
+            Assert.Equal(streamingResults[i], batchResults.Values[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void BatchCalculateSpan_Matches_Streaming()
+    {
+        var gbm = new GBM();
+        var bars = gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        var tema = new Tema(10);
+        var streamingResults = new List<double>();
+        for (int i = 0; i < series.Count; i++)
+        {
+            streamingResults.Add(tema.Update(series[i]).Value);
+        }
+
+        var spanResults = new double[series.Count];
+        Tema.Batch(series.Values, spanResults, 10);
+
+        for (int i = 0; i < spanResults.Length; i++)
+        {
+            Assert.Equal(streamingResults[i], spanResults[i], 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Chainability_Works()
+    {
+        var tema = new Tema(10);
+        var gbm = new GBM();
+        var bars = gbm.Fetch(10, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var series = bars.Close;
+
+        // Test TSeries chain
+        var result = tema.Update(series);
+        Assert.NotNull(result);
+        Assert.IsType<TSeries>(result);
+
+        // Test TValue chain
+        var result2 = tema.Update(series[0]);
+        Assert.IsType<TValue>(result2);
+    }
+
+    [Fact]
+    public void Constructor_InvalidParameters_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new Tema(0));
+        Assert.Throws<ArgumentException>(() => new Tema(-1));
+        Assert.Throws<ArgumentException>(() => new Tema(0.0));
+        Assert.Throws<ArgumentException>(() => new Tema(1.0));
+    }
+}

lib/trends_IIR/tema/tests/Tema.Validation.Tests.cs

@@ -0,0 +1,122 @@
+using Skender.Stock.Indicators;
+using TALib;
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public class TemaValidationTests
+{
+    // Note: OoplesFinance TEMA implementation diverges significantly from Skender, TA-Lib, and Tulip
+    // for larger periods, likely due to different initialization or smoothing logic.
+    // Therefore, we do not validate against Ooples for TEMA.
+
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+
+    public TemaValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+        _testData = new ValidationTestData();
+    }
+
+    [Fact]
+    public void Validate_Skender_Batch()
+    {
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        foreach (var period in periods)
+        {
+            // Calculate QuanTAlib TEMA (batch TSeries)
+            var tema = new global::QuanTAlib.Tema(period);
+            var qResult = tema.Update(_testData.Data);
+
+            // Calculate Skender TEMA
+            var sResult = _testData.SkenderQuotes.GetTema(period).ToList();
+
+            // Compare last 100 records
+            ValidationHelper.VerifyData(qResult, sResult, x => x.Tema, tolerance: ValidationHelper.SkenderTolerance);
+        }
+        _output.WriteLine("TEMA Batch(TSeries) validated successfully against Skender.Stock.Indicators");
+    }
+
+    [Fact]
+    public void Validate_Talib_Batch()
+    {
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        // Prepare data for TA-Lib (double[])
+        double[] output = new double[_testData.RawData.Length];
+
+        foreach (var period in periods)
+        {
+            // Calculate QuanTAlib TEMA (batch TSeries)
+            var tema = new global::QuanTAlib.Tema(period);
+            var qResult = tema.Update(_testData.Data);
+
+            // Calculate TA-Lib TEMA
+            var retCode = TALib.Functions.Tema<double>(_testData.RawData.Span, 0..^0, output, out var outRange, period);
+            Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+            int lookback = TALib.Functions.TemaLookback(period);
+
+            // Compare last 100 records
+            ValidationHelper.VerifyData(qResult, output, outRange, lookback, tolerance: ValidationHelper.TalibTolerance);
+        }
+        _output.WriteLine("TEMA Batch(TSeries) validated successfully against TA-Lib");
+    }
+
+    [Fact]
+    public void Validate_Tulip_Batch()
+    {
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        foreach (var period in periods)
+        {
+            // Calculate QuanTAlib TEMA (batch TSeries)
+            var tema = new global::QuanTAlib.Tema(period);
+            var qResult = tema.Update(_testData.Data);
+
+            // Calculate Tulip TEMA
+            var temaIndicator = Tulip.Indicators.tema;
+            double[][] inputs = { _testData.RawData.ToArray() };
+            double[] options = { period };
+
+            // Tulip TEMA lookback is 3*(period-1)
+            int lookback = 3 * (period - 1);
+            double[][] outputs = { new double[_testData.RawData.Length - lookback] };
+
+            temaIndicator.Run(inputs, options, outputs);
+            var tResult = outputs[0];
+
+            // Compare last 100 records
+            ValidationHelper.VerifyData(qResult, tResult, lookback, tolerance: ValidationHelper.TulipTolerance);
+        }
+        _output.WriteLine("TEMA Batch(TSeries) validated successfully against Tulip");
+    }
+
+    [Fact]
+    public void Validate_Talib_Span()
+    {
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        // Prepare data
+        double[] talibOutput = new double[_testData.RawData.Length];
+
+        foreach (var period in periods)
+        {
+            // Calculate QuanTAlib TEMA (Span API)
+            double[] qOutput = new double[_testData.RawData.Length];
+            global::QuanTAlib.Tema.Batch(_testData.RawData.Span, qOutput.AsSpan(), period);
+
+            // Calculate TA-Lib TEMA
+            var retCode = TALib.Functions.Tema<double>(_testData.RawData.Span, 0..^0, talibOutput, out var outRange, period);
+            Assert.Equal(TALib.Core.RetCode.Success, retCode);
+
+            int lookback = TALib.Functions.TemaLookback(period);
+
+            // Compare last 100 records
+            ValidationHelper.VerifyData(qOutput, talibOutput, outRange, lookback, tolerance: ValidationHelper.TalibTolerance);
+        }
+        _output.WriteLine("TEMA Span validated successfully against TA-Lib");
+    }
+}