filters update

lib/oscillators/stc/Stc.Quantower.Tests.cs

@@ -0,0 +1,210 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class StcIndicatorTests
+{
+    [Fact]
+    public void StcIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new StcIndicator();
+
+        Assert.Equal(12, indicator.CycleLength);
+        Assert.Equal(26, indicator.FastLength);
+        Assert.Equal(50, indicator.SlowLength);
+        Assert.Equal(StcSmoothing.Sigmoid, indicator.Smoothing);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("STC - Schaff Trend Cycle", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void StcIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new StcIndicator();
+
+        Assert.Equal(0, StcIndicator.MinHistoryDepths);
+        Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void StcIndicator_ShortName_IncludesParameters()
+    {
+        var indicator = new StcIndicator
+        {
+            CycleLength = 10,
+            FastLength = 23,
+            SlowLength = 50,
+            Smoothing = StcSmoothing.Ema,
+        };
+
+        // Format is "STC {CycleLength}:{FastLength}:{SlowLength}:{Smoothing}:{Source}"
+        // e.g. "STC 10:23:50:Ema:Close"
+        string shortName = indicator.ShortName;
+
+        Assert.Contains("STC", shortName, StringComparison.Ordinal);
+        Assert.Contains("10", shortName, StringComparison.Ordinal);
+        Assert.Contains("23", shortName, StringComparison.Ordinal);
+        Assert.Contains("50", shortName, StringComparison.Ordinal);
+        Assert.Contains("Ema", shortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StcIndicator_Initialize_CreatesInternalStc()
+    {
+        var indicator = new StcIndicator();
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+        Assert.Equal("STC", indicator.LinesSeries[0].Name);
+    }
+
+    [Fact]
+    public void StcIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new StcIndicator { CycleLength = 5, FastLength = 10, SlowLength = 20 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+
+        // We must feed bars one by one to simulate history for stateful indicators
+        for (int i = 0; i < 50; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100);
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Line series should have values
+        Assert.Equal(50, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0))); // GetValue(0) is the most recent
+    }
+
+    [Fact]
+    public void StcIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new StcIndicator { CycleLength = 5, FastLength = 10, SlowLength = 20 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Feed enough history to warm up
+        for (int i = 0; i < 50; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(50), 102, 108, 100, 106);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.True(indicator.LinesSeries[0].Count > 0);
+    }
+
+    [Fact]
+    public void StcIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new StcIndicator { CycleLength = 5, FastLength = 10, SlowLength = 20 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Feed warmup bars
+        for (int i = 0; i < 50; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Update with NewTick (same bar, new price potentially, but reusing last bar in this mock)
+        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 StcIndicator_MultipleUpdates_ProducesCorrectSequence()
+    {
+        var indicator = new StcIndicator { CycleLength = 10, FastLength = 12, SlowLength = 26 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        // Generate enough price action to clear warmup (SlowLength + 2*CycleLength = 26 + 20 = 46)
+        // We'll generate 100 bars to be safe
+        double[] closes = new double[100];
+        for (int i = 0; i < 100; i++)
+        {
+            closes[i] = 100 + Math.Sin(i * 0.1) * 10;
+        }
+
+        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);
+        }
+
+        // The last value should be finite (we are well past 46)
+        double lastVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(lastVal));
+    }
+
+    [Fact]
+    public void StcIndicator_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 StcIndicator
+            {
+                CycleLength = 10,
+                FastLength = 23,
+                SlowLength = 50,
+                Source = source,
+            };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+
+            // Feed enough bars to produce a value
+            // Warmup = 50 + 20 = 70 approx
+            for (int i = 0; i < 80; i++)
+            {
+                indicator.HistoricalData.AddBar(now.AddMinutes(i), 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 StcIndicator_Parameters_CanBeChanged()
+    {
+        var indicator = new StcIndicator();
+
+        indicator.CycleLength = 20;
+        Assert.Equal(20, indicator.CycleLength);
+
+        indicator.FastLength = 12;
+        Assert.Equal(12, indicator.FastLength);
+
+        indicator.SlowLength = 26;
+        Assert.Equal(26, indicator.SlowLength);
+
+        indicator.Smoothing = StcSmoothing.Digital;
+        Assert.Equal(StcSmoothing.Digital, indicator.Smoothing);
+    }
+}

lib/oscillators/stc/Stc.Quantower.cs

@@ -0,0 +1,69 @@
+using System.Drawing;
+using System.Runtime.CompilerServices;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib;
+
+[SkipLocalsInit]
+public sealed class StcIndicator : Indicator, IWatchlistIndicator
+{
+    [InputParameter("Cycle Length", sortIndex: 1, 2, 2000, 1, 0)]
+    public int CycleLength { get; set; } = 12;
+
+    [InputParameter("Fast Length", sortIndex: 2, 2, 2000, 1, 0)]
+    public int FastLength { get; set; } = 26;
+
+    [InputParameter("Slow Length", sortIndex: 3, 2, 2000, 1, 0)]
+    public int SlowLength { get; set; } = 50;
+
+    [InputParameter("Smoothing", sortIndex: 4, variants: new object[] {
+        "None", StcSmoothing.None,
+        "EMA", StcSmoothing.Ema,
+        "Sigmoid", StcSmoothing.Sigmoid,
+        "Digital", StcSmoothing.Digital,
+    })]
+    public StcSmoothing Smoothing { get; set; } = StcSmoothing.Sigmoid;
+
+    [IndicatorExtensions.DataSourceInput]
+    public SourceType Source { get; set; } = SourceType.Close;
+
+    [InputParameter("Show cold values", sortIndex: 21)]
+    public bool ShowColdValues { get; set; } = true;
+
+    private Stc _stc = null!;
+    private readonly LineSeries _series;
+    private string _sourceName = null!;
+    private Func<IHistoryItem, double> _priceSelector = null!;
+
+    public static int MinHistoryDepths => 0;
+    int IWatchlistIndicator.MinHistoryDepths => MinHistoryDepths;
+
+    public override string ShortName => $"STC {CycleLength}:{FastLength}:{SlowLength}:{Smoothing}:{_sourceName}";
+
+    public StcIndicator()
+    {
+        OnBackGround = true;
+        SeparateWindow = true;
+        Name = "STC - Schaff Trend Cycle";
+        Description = "Schaff Trend Cycle Oscillator";
+        _series = new LineSeries(name: "STC", color: IndicatorExtensions.Oscillators, width: 2, style: LineStyle.Solid);
+        AddLineSeries(_series);
+    }
+
+    protected override void OnInit()
+    {
+        _priceSelector = Source.GetPriceSelector();
+        _sourceName = Source.ToString();
+        _stc = new Stc(kPeriod: CycleLength, dPeriod: CycleLength, fastLength: FastLength, slowLength: SlowLength, smoothing: Smoothing);
+        base.OnInit();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override void OnUpdate(UpdateArgs args)
+    {
+        bool isNew = args.IsNewBar();
+        var item = HistoricalData[Count - 1, SeekOriginHistory.Begin];
+        double value = _stc.Update(new TValue(item.TimeLeft.Ticks, _priceSelector(item)), isNew).Value;
+        _series.SetValue(value, _stc.IsHot, ShowColdValues);
+    }
+}

lib/oscillators/stc/Stc.Tests.cs

@@ -0,0 +1,132 @@
+using System;
+using Xunit;
+
+namespace QuanTAlib;
+
+public class StcTests
+{
+    private const int CycleLength = 12;
+    private const int FastLength = 26;
+    private const int SlowLength = 50;
+
+    private static Stc CreateDefaultStc() => new(kPeriod: CycleLength, dPeriod: CycleLength, fastLength: FastLength, slowLength: SlowLength, smoothing: StcSmoothing.Sigmoid);
+
+    [Fact]
+    public void Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Stc(kPeriod: 1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Stc(dPeriod: 0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Stc(fastLength: 1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Stc(slowLength: 1));
+    }
+
+    [Fact]
+    public void Calc_ReturnsValue()
+    {
+        var stc = CreateDefaultStc();
+        var result = stc.Update(new TValue(DateTime.UtcNow, 100));
+        // Expect NaN during warmup
+        Assert.True(double.IsNaN(result.Value) || double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Properties_Accessible()
+    {
+        var stc = CreateDefaultStc();
+        Assert.Equal(0, stc.Last.Value); // Initial value before updates
+        Assert.False(stc.IsHot);
+        Assert.Contains("Stc", stc.Name, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void IsHot_BecomesTrueWhenBufferFull()
+    {
+        var stc = CreateDefaultStc();
+        int warmup = stc.WarmupPeriod;
+
+        for (int i = 0; i < warmup - 1; i++)
+        {
+            stc.Update(new TValue(DateTime.UtcNow, 100));
+            Assert.False(stc.IsHot);
+        }
+
+        stc.Update(new TValue(DateTime.UtcNow, 100));
+        Assert.True(stc.IsHot);
+    }
+
+    [Fact]
+    public void BatchCalc_MatchesIterativeCalc()
+    {
+        var iterativeStc = CreateDefaultStc();
+        var batchStc = CreateDefaultStc();
+        var series = new TSeries();
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+
+        for (int i = 0; i < 200; i++)
+        {
+            var bar = gbm.Next();
+            series.Add(bar.Time, bar.Close);
+            iterativeStc.Update(new TValue(bar.Time, bar.Close));
+        }
+
+        var batchResult = batchStc.Update(series);
+
+        Assert.Equal(iterativeStc.Last.Value, batchResult.Last.Value, 1e-9);
+    }
+
+    [Fact]
+    public void SpanBatch_MatchesTSeriesBatch()
+    {
+        // Use default parameters for static calculation
+        var series = new TSeries();
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+        double[] input = new double[200];
+        double[] output = new double[200];
+
+        for (int i = 0; i < 200; i++)
+        {
+            var bar = gbm.Next();
+            series.Add(bar.Time, bar.Close);
+            input[i] = bar.Close;
+        }
+
+        var batchStc = CreateDefaultStc();
+        var tseriesResult = batchStc.Update(series);
+
+        Stc.Batch(input.AsSpan(), output.AsSpan(), kPeriod: CycleLength, dPeriod: CycleLength, fastLength: FastLength, slowLength: SlowLength, smoothing: StcSmoothing.Sigmoid);
+
+        // Compare last value
+        Assert.Equal(tseriesResult.Last.Value, output[^1], 1e-9);
+    }
+
+    [Fact]
+    public void NaN_Input_HandledSafely()
+    {
+        var stc = CreateDefaultStc();
+        stc.Update(new TValue(DateTime.UtcNow, 100));
+        var result = stc.Update(new TValue(DateTime.UtcNow, double.NaN));
+        // Should be NaN during warmup
+        Assert.True(double.IsNaN(result.Value) || double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void SmoothingOptions_ProduceDifferentResults()
+    {
+        var stcSigmoid = new Stc(kPeriod: 10, dPeriod: 10, fastLength: 20, slowLength: 40, smoothing: StcSmoothing.Sigmoid);
+        var stcEma = new Stc(kPeriod: 10, dPeriod: 10, fastLength: 20, slowLength: 40, smoothing: StcSmoothing.Ema);
+        var stcDigital = new Stc(kPeriod: 10, dPeriod: 10, fastLength: 20, slowLength: 40, smoothing: StcSmoothing.Digital);
+
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
+
+        for (int i = 0; i < 100; i++)
+        {
+            double val = gbm.Next().Close;
+            stcSigmoid.Update(new TValue(DateTime.UtcNow, val));
+            stcEma.Update(new TValue(DateTime.UtcNow, val));
+            stcDigital.Update(new TValue(DateTime.UtcNow, val));
+        }
+
+        Assert.NotEqual(stcSigmoid.Last.Value, stcEma.Last.Value);
+        Assert.NotEqual(stcSigmoid.Last.Value, stcDigital.Last.Value);
+    }
+}

lib/oscillators/stc/Stc.Validation.Tests.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Linq;
+using Skender.Stock.Indicators;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace QuanTAlib.Tests;
+
+public sealed class StcValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+
+    public StcValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+        _testData = new ValidationTestData();
+    }
+
+    public void Dispose()
+    {
+        _testData.Dispose();
+    }
+
+    [Fact]
+    public void Validate_Skender_Stc_Deviation()
+    {
+        // Skender's STC implementation uses a "Single Smoothed" approach (Stoch of MACD).
+        // QuanTAlib implements the standard "Double Smoothed" approach (Stoch of Stoch of MACD),
+        // as originally defined by Schaff.
+        //
+        // Example mismatch at index 333:
+        // QuanTAlib (Double Smoothed) = 50.0
+        // Skender (Single Smoothed) = 97.05
+        //
+        // This test documents this known deviation rather than failing on it.
+
+        const int cycle = 10;
+        int fast = 23;
+        int slow = 50;
+
+        var sResult = _testData.SkenderQuotes.GetStc(cycle, fast, slow).ToList();
+        var qStc = new Stc(kPeriod: cycle, dPeriod: 3, fastLength: fast, slowLength: slow, smoothing: StcSmoothing.Ema);
+        var qResult = qStc.Update(_testData.Data);
+
+        // Skender recommends S+C+250 warmup. 50+10+250 = 310.
+        int skip = 310;
+        double sumSq = 0;
+        int count = 0;
+
+        for (int i = skip; i < qResult.Count; i++)
+        {
+            double sVal = sResult[i].Stc ?? double.NaN;
+            double qVal = qResult[i].Value;
+
+            if (!double.IsNaN(sVal) && !double.IsNaN(qVal))
+            {
+                sumSq += (sVal - qVal) * (sVal - qVal);
+                count++;
+            }
+        }
+
+        double rmse = Math.Sqrt(sumSq / count);
+        _output.WriteLine($"Known Methodology Deviation - RMSE: {rmse:F4}");
+
+        // Assert that we are essentially different (RMSE > 5.0 implies significant deviation)
+        // If they accidentally matched (e.g. if we broke our logic to match Skender), this should fail.
+        Assert.True(rmse > 5.0, "QuanTAlib STC matches Skender STC, which suggests regression to Single Smoothed logic.");
+
+        // Assert values are valid
+        for (int i = skip; i < qResult.Count; i++)
+        {
+            Assert.True(double.IsFinite(qResult[i].Value));
+            Assert.InRange(qResult[i].Value, 0, 100);
+        }
+    }
+}

lib/oscillators/stc/Stc.cs

@@ -0,0 +1,675 @@
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace QuanTAlib;
+
+/// <summary>
+/// Defines the smoothing method applied to the final STC output.
+/// </summary>
+public enum StcSmoothing { None = 0, Ema = 1, Sigmoid = 2, Digital = 3 }
+
+/// <summary>
+/// STC: Schaff Trend Cycle - A cycle oscillator that combines MACD and Stochastic to detect market trends with improved speed and accuracy.
+/// </summary>
+/// <remarks>
+/// The Schaff Trend Cycle (STC), developed by Doug Schaff, is an oscillator that moves between 0 and 100.
+/// It identifies market trends and cycles by applying a Stochastic calculation to the MACD line,
+/// and then smoothing the result. This results in an indicator that is faster than MACD and smoother than Stochastic.
+///
+/// Algorithm:
+/// 1. Calculate MACD = Exponential Moving Average (Fast) - Exponential Moving Average (Slow).
+/// 2. Calculate %K (Stoch K) of the MACD over a specified period.
+/// 3. Smooth %K with a fast average to get %D (Stoch D).
+/// 4. Re-calculate %K of the %D value (Stoch of Stoch).
+/// 5. Smooth the result again to produce the final STC value.
+///
+/// Properties:
+/// - Ranges from 0 to 100.
+/// - High values (>75) indicate overbought conditions.
+/// - Low values (<25) indicate oversold conditions.
+/// - Signals are generated when the indicator crosses these thresholds.
+/// - Minimizes false signals found in traditional MACD or Stochastic indicators.
+///
+/// Key Insight:
+/// By performing a double stochastic calculation on the MACD (Stochastic of the Stochastic of MACD),
+/// STC emphasizes the cyclic nature of trends while reducing noise.
+/// </remarks>
+[SkipLocalsInit]
+public sealed class Stc : AbstractBase
+{
+    private readonly StcSmoothing _smoothing;
+
+    private readonly double _fastAlpha;
+    private readonly double _slowAlpha;
+    private readonly double _dAlpha;
+
+    private readonly RingBuffer _macdBuf;
+    private readonly RingBuffer _stoch1Buf;
+    private readonly ITValuePublisher? _publisher;
+    private readonly TValuePublishedHandler? _handler;
+    private bool _isNew;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private record struct State
+    {
+        public double FastEma;
+        public double SlowEma;
+        public double Stoch1Ema;
+        public double Stoch2Ema;
+        public double PrevStc;
+        public double LastFiniteInput;
+        public bool HasFiniteInput;
+
+        public double MacdMin;
+        public double MacdMax;
+        public double Stoch1Min;
+        public double Stoch1Max;
+    }
+
+    private State _s, _ps;
+    private int _samples;
+
+    public Stc(
+        int kPeriod = 10,
+        int dPeriod = 3,
+        int fastLength = 23,
+        int slowLength = 50,
+        StcSmoothing smoothing = StcSmoothing.Ema)
+    {
+        ArgumentOutOfRangeException.ThrowIfLessThan(kPeriod, 2);
+        ArgumentOutOfRangeException.ThrowIfLessThan(dPeriod, 1);
+        ArgumentOutOfRangeException.ThrowIfLessThan(fastLength, 2);
+        ArgumentOutOfRangeException.ThrowIfLessThan(slowLength, 2);
+
+        _smoothing = smoothing;
+
+        _fastAlpha = 2.0 / (fastLength + 1.0);
+        _slowAlpha = 2.0 / (slowLength + 1.0);
+        _dAlpha = 2.0 / (dPeriod + 1.0);
+
+        int bufSize = kPeriod;
+        _macdBuf = new RingBuffer(bufSize);
+        _stoch1Buf = new RingBuffer(bufSize);
+
+        Name = $"Stc(k={kPeriod},d={dPeriod},fast={fastLength},slow={slowLength},{smoothing})";
+        WarmupPeriod = slowLength + bufSize;
+
+        Reset();
+    }
+
+    public Stc(ITValuePublisher source, int kPeriod = 10, int dPeriod = 3, int fastLength = 23, int slowLength = 50, StcSmoothing smoothing = StcSmoothing.Ema)
+        : this(kPeriod, dPeriod, fastLength, slowLength, smoothing)
+    {
+        _publisher = source;
+        _handler = Handle;
+        source.Pub += _handler;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void Handle(object? sender, in TValueEventArgs args)
+    {
+        Update(args.Value, args.IsNew);
+    }
+
+    public bool IsNew => _isNew;
+    public override bool IsHot => _samples >= WarmupPeriod;
+
+    public override void Reset()
+    {
+        _s = new State
+        {
+            FastEma = double.NaN,
+            SlowEma = double.NaN,
+            Stoch1Ema = double.NaN,
+            Stoch2Ema = double.NaN,
+            PrevStc = double.NaN,
+            LastFiniteInput = double.NaN,
+            HasFiniteInput = false,
+            MacdMin = double.PositiveInfinity,
+            MacdMax = double.NegativeInfinity,
+            Stoch1Min = double.PositiveInfinity,
+            Stoch1Max = double.NegativeInfinity,
+        };
+        _ps = _s;
+        _samples = 0;
+        _macdBuf.Clear();
+        _stoch1Buf.Clear();
+        Last = default;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static double Clamp100(double x)
+    {
+        if (double.IsNaN(x))
+        {
+            return x;
+        }
+
+        return Math.Clamp(x, 0, 100);
+    }
+
+    /// <summary>
+    /// Applies final smoothing to stoch2Raw based on smoothing mode.
+    /// Shared between Update() and Calculate() to eliminate duplication.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static double ApplySmoothing(double stoch2Raw, StcSmoothing smoothing, double dAlpha, ref double stoch2Ema, ref double prevStc)
+    {
+        double stc;
+        switch (smoothing)
+        {
+            case StcSmoothing.Ema:
+                stoch2Ema = double.IsNaN(stoch2Ema)
+                    ? stoch2Raw
+                    : Math.FusedMultiplyAdd(dAlpha, stoch2Raw - stoch2Ema, stoch2Ema);
+                stc = Clamp100(stoch2Ema);
+                break;
+
+            case StcSmoothing.Sigmoid:
+                stc = 100.0 / (1.0 + Math.Exp(-0.1 * (stoch2Raw - 50.0)));
+                break;
+
+            case StcSmoothing.Digital:
+                if (stoch2Raw > 75)
+                {
+                    stc = 100;
+                }
+                else if (stoch2Raw < 25)
+                {
+                    stc = 0;
+                }
+                else
+                {
+                    stc = double.IsNaN(prevStc) ? stoch2Raw : prevStc;
+                }
+
+                break;
+
+            default: // Includes StcSmoothing.None
+                stc = stoch2Raw;
+                break;
+        }
+        prevStc = stc;
+        return stc;
+    }
+
+    /// <summary>
+    /// Updates min/max tracking for a sliding window.
+    /// Returns true if a full rescan is needed (removed value was at boundary).
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool UpdateMinMaxCore(double added, double removed, bool hasRemoved, ref double min, ref double max)
+    {
+        if (double.IsNaN(added))
+        {
+            return false;
+        }
+
+        bool expandMin = added < min;
+        bool expandMax = added > max;
+
+        if (!hasRemoved)
+        {
+            if (expandMin)
+            {
+                min = added;
+            }
+
+            if (expandMax)
+            {
+                max = added;
+            }
+
+            return false;
+        }
+
+        // Use relative tolerance for floating-point comparison
+        double tolerance = Math.Max(Math.Abs(min), Math.Abs(max)) * 1e-12;
+        if (tolerance < 1e-15)
+        {
+            tolerance = 1e-15; // minimum absolute tolerance
+        }
+
+        bool removedMin = Math.Abs(removed - min) <= tolerance;
+        bool removedMax = Math.Abs(removed - max) <= tolerance;
+
+        if (expandMin)
+        {
+            min = added;
+        }
+
+        if (expandMax)
+        {
+            max = added;
+        }
+
+        return (removedMin && !expandMin) || (removedMax && !expandMax);
+    }
+
+    /// <summary>
+    /// Rescans a span to find new min/max values.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void RescanMinMax(ReadOnlySpan<double> span, ref double min, ref double max)
+    {
+        min = double.PositiveInfinity;
+        max = double.NegativeInfinity;
+        foreach (double v in span)
+        {
+            if (double.IsNaN(v))
+            {
+                continue;
+            }
+
+            if (v < min)
+            {
+                min = v;
+            }
+
+            if (v > max)
+            {
+                max = v;
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void UpdateMinMax(double added, double removed, bool hasRemoved, RingBuffer buf, ref double min, ref double max)
+    {
+        if (UpdateMinMaxCore(added, removed, hasRemoved, ref min, ref max))
+        {
+            var span = buf.IsFull ? buf.InternalBuffer : buf.GetSpan();
+            RescanMinMax(span, ref min, ref max);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void UpdateMinMax(double added, double removed, bool hasRemoved, ReadOnlySpan<double> buf, ref double min, ref double max)
+    {
+        if (UpdateMinMaxCore(added, removed, hasRemoved, ref min, ref max))
+        {
+            RescanMinMax(buf, ref min, ref max);
+        }
+    }
+
+    // skipcq: CS-R1140 - Cyclomatic complexity justified: STC algorithm requires
+    // sequential MACD→Stoch1→Stoch2→Smoothing pipeline with min/max tracking per stage.
+    // Splitting would fragment the tightly-coupled state machine and harm readability.
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override TValue Update(TValue input, bool isNew = true)
+    {
+        _isNew = isNew;
+        if (isNew)
+        {
+            _ps = _s;
+        }
+        else
+        {
+            _s = _ps;
+        }
+
+        var s = _s;
+
+        double x = input.Value;
+
+        if (!double.IsFinite(x))
+        {
+            if (!s.HasFiniteInput)
+            {
+                Last = new TValue(input.Time, double.NaN);
+                PubEvent(Last, isNew);
+                return Last;
+            }
+            x = s.LastFiniteInput;
+        }
+        else
+        {
+            s.LastFiniteInput = x;
+            s.HasFiniteInput = true;
+        }
+
+        // 1) MACD
+        s.FastEma = double.IsNaN(s.FastEma) ? x : Math.FusedMultiplyAdd(_fastAlpha, x - s.FastEma, s.FastEma);
+
+        s.SlowEma = double.IsNaN(s.SlowEma) ? x : Math.FusedMultiplyAdd(_slowAlpha, x - s.SlowEma, s.SlowEma);
+
+        double macd = s.FastEma - s.SlowEma;
+
+        double removedMacd = 0;
+        bool hasRemovedMacd;
+        if (isNew)
+        {
+            hasRemovedMacd = _macdBuf.IsFull;
+            removedMacd = _macdBuf.Add(macd);
+        }
+        else
+        {
+            removedMacd = _macdBuf.Newest;
+            hasRemovedMacd = _macdBuf.Count > 0;
+            _macdBuf.UpdateNewest(macd);
+        }
+        UpdateMinMax(macd, removedMacd, hasRemovedMacd, _macdBuf, ref s.MacdMin, ref s.MacdMax);
+
+        // 2) Stoch1 of MACD
+        double stoch1Raw;
+        if (_macdBuf.IsFull)
+        {
+            double span = s.MacdMax - s.MacdMin;
+            if (span > double.Epsilon)
+            {
+                stoch1Raw = 100.0 * (macd - s.MacdMin) / span;
+            }
+            else
+            {
+                stoch1Raw = double.IsNaN(s.Stoch1Ema) ? 50.0 : s.Stoch1Ema;
+            }
+
+            stoch1Raw = Clamp100(stoch1Raw);
+        }
+        else
+        {
+            stoch1Raw = 50.0;
+        }
+
+        // Smooth Stoch1
+        if (!double.IsNaN(stoch1Raw))
+        {
+            s.Stoch1Ema = double.IsNaN(s.Stoch1Ema)
+                ? stoch1Raw
+                : Math.FusedMultiplyAdd(_dAlpha, stoch1Raw - s.Stoch1Ema, s.Stoch1Ema);
+        }
+
+        double stoch1 = double.NaN;
+        if (!double.IsNaN(s.Stoch1Ema))
+        {
+            stoch1 = Clamp100(s.Stoch1Ema);
+
+            double removedStoch1 = 0;
+            bool hasRemovedStoch1;
+            if (isNew)
+            {
+                hasRemovedStoch1 = _stoch1Buf.IsFull;
+                removedStoch1 = _stoch1Buf.Add(stoch1);
+            }
+            else
+            {
+                removedStoch1 = _stoch1Buf.Newest;
+                hasRemovedStoch1 = _stoch1Buf.Count > 0;
+                _stoch1Buf.UpdateNewest(stoch1);
+            }
+            UpdateMinMax(stoch1, removedStoch1, hasRemovedStoch1, _stoch1Buf, ref s.Stoch1Min, ref s.Stoch1Max);
+        }
+
+        // 3) Stoch2 of Stoch1
+        double stoch2Raw;
+        if (_stoch1Buf.IsFull)
+        {
+            double span = s.Stoch1Max - s.Stoch1Min;
+            if (span > double.Epsilon)
+            {
+                stoch2Raw = 100.0 * (stoch1 - s.Stoch1Min) / span;
+            }
+            else
+            {
+                stoch2Raw = double.IsNaN(s.Stoch2Ema) ? stoch1 : s.Stoch2Ema;
+            }
+
+            stoch2Raw = Clamp100(stoch2Raw);
+        }
+        else
+        {
+            stoch2Raw = stoch1;
+        }
+
+        // 4) Final Smooth
+        double stc = double.NaN;
+        if (!double.IsNaN(stoch2Raw))
+        {
+            stc = ApplySmoothing(stoch2Raw, _smoothing, _dAlpha, ref s.Stoch2Ema, ref s.PrevStc);
+        }
+
+        if (isNew)
+        {
+            _samples++;
+        }
+
+        _s = s;
+        Last = new TValue(input.Time, stc);
+        PubEvent(Last, isNew);
+        return Last;
+    }
+
+    public override TSeries Update(TSeries source)
+    {
+        var result = new TSeries();
+        foreach (var item in source)
+        {
+            result.Add(Update(item, isNew: true));
+        }
+
+        return result;
+    }
+
+    public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
+    {
+        foreach (double v in source)
+        {
+            Update(new TValue(DateTime.MinValue, v), isNew: true);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing && _publisher != null && _handler != null)
+        {
+            _publisher.Pub -= _handler;
+        }
+        base.Dispose(disposing);
+    }
+
+    /// <summary>
+    /// Static convenience method that creates a new Stc instance and processes the entire series.
+    /// </summary>
+    public static TSeries Batch(TSeries source, int kPeriod = 10, int dPeriod = 3, int fastLength = 23, int slowLength = 50, StcSmoothing smoothing = StcSmoothing.Ema)
+    {
+        var indicator = new Stc(kPeriod, dPeriod, fastLength, slowLength, smoothing);
+        return indicator.Update(source);
+    }
+
+    // skipcq: CS-R1140 - Cyclomatic complexity justified: span-based Calculate must
+    // replicate the full STC state machine inline for zero-allocation performance.
+    // The sequential MACD→Stoch1→Stoch2→Smoothing pipeline cannot be decomposed
+    // without introducing heap allocations or sacrificing inlining opportunities.
+    public static void Batch(ReadOnlySpan<double> source, Span<double> output,
+        int kPeriod = 10, int dPeriod = 3, int fastLength = 23, int slowLength = 50, StcSmoothing smoothing = StcSmoothing.Ema)
+    {
+        if (source.Length != output.Length)
+        {
+            throw new ArgumentException("Source and output spans must be of equal length.", nameof(output));
+        }
+
+        double fastAlpha = 2.0 / (fastLength + 1.0);
+        double slowAlpha = 2.0 / (slowLength + 1.0);
+        double dAlpha = 2.0 / (dPeriod + 1.0);
+
+        double fastEma = double.NaN;
+        double slowEma = double.NaN;
+        double stoch1Ema = double.NaN;
+        double stoch2Ema = double.NaN;
+        double prevStc = double.NaN;
+        double lastFiniteInput = double.NaN;
+        bool hasFiniteInput = false;
+
+        const int StackallocThreshold = 256;
+        double[]? rentedMacd = null;
+        double[]? rentedStoch1 = null;
+
+        scoped Span<double> macdBuf;
+        scoped Span<double> stoch1Buf;
+
+        if (kPeriod <= StackallocThreshold)
+        {
+            macdBuf = stackalloc double[kPeriod];
+            stoch1Buf = stackalloc double[kPeriod];
+        }
+        else
+        {
+            rentedMacd = ArrayPool<double>.Shared.Rent(kPeriod);
+            macdBuf = rentedMacd.AsSpan(0, kPeriod);
+            rentedStoch1 = ArrayPool<double>.Shared.Rent(kPeriod);
+            stoch1Buf = rentedStoch1.AsSpan(0, kPeriod);
+        }
+
+        try
+        {
+            int macdIdx = 0;
+            int stoch1Idx = 0;
+            int macdCount = 0;
+            int stoch1Count = 0;
+
+            double macdMin = double.PositiveInfinity;
+            double macdMax = double.NegativeInfinity;
+            double stoch1Min = double.PositiveInfinity;
+            double stoch1Max = double.NegativeInfinity;
+
+            for (int i = 0; i < source.Length; i++)
+            {
+                double x = source[i];
+
+                if (!double.IsFinite(x))
+                {
+                    if (!hasFiniteInput)
+                    {
+                        output[i] = double.NaN;
+                        continue;
+                    }
+                    x = lastFiniteInput;
+                }
+                else
+                {
+                    lastFiniteInput = x;
+                    hasFiniteInput = true;
+                }
+
+                // 1) MACD
+                fastEma = double.IsNaN(fastEma) ? x : Math.FusedMultiplyAdd(fastAlpha, x - fastEma, fastEma);
+                slowEma = double.IsNaN(slowEma) ? x : Math.FusedMultiplyAdd(slowAlpha, x - slowEma, slowEma);
+
+                double macd = fastEma - slowEma;
+
+                // Buffer MACD
+                bool macdHasRemoved = macdCount == kPeriod;
+                double macdRemoved = macdBuf[macdIdx];
+                macdBuf[macdIdx] = macd;
+                macdIdx = (macdIdx + 1) % kPeriod;
+                if (!macdHasRemoved)
+                {
+                    macdCount++;
+                }
+
+                ReadOnlySpan<double> macdValidSpan = macdBuf.Slice(0, macdCount);
+                UpdateMinMax(macd, macdRemoved, macdHasRemoved, macdValidSpan, ref macdMin, ref macdMax);
+
+                // 2) Stoch1
+                double stoch1Raw;
+                if (macdCount == kPeriod)
+                {
+                    double span = macdMax - macdMin;
+                    if (span > double.Epsilon)
+                    {
+                        stoch1Raw = 100.0 * (macd - macdMin) / span;
+                    }
+                    else
+                    {
+                        stoch1Raw = double.IsNaN(stoch1Ema) ? 50.0 : stoch1Ema;
+                    }
+
+                    stoch1Raw = Clamp100(stoch1Raw);
+                }
+                else
+                {
+                    stoch1Raw = 50.0;
+                }
+
+                // Smooth Stoch1
+                if (!double.IsNaN(stoch1Raw))
+                {
+                    stoch1Ema = double.IsNaN(stoch1Ema)
+                        ? stoch1Raw
+                        : Math.FusedMultiplyAdd(dAlpha, stoch1Raw - stoch1Ema, stoch1Ema);
+                }
+
+                double stoch1 = double.NaN;
+                if (!double.IsNaN(stoch1Ema))
+                {
+                    stoch1 = Clamp100(stoch1Ema);
+
+                    // Buffer Stoch1
+                    bool stochHasRemoved = stoch1Count == kPeriod;
+                    double stochRemoved = stoch1Buf[stoch1Idx];
+                    stoch1Buf[stoch1Idx] = stoch1;
+                    stoch1Idx = (stoch1Idx + 1) % kPeriod;
+                    if (!stochHasRemoved)
+                    {
+                        stoch1Count++;
+                    }
+
+                    ReadOnlySpan<double> stochValidSpan = stoch1Buf.Slice(0, stoch1Count);
+                    UpdateMinMax(stoch1, stochRemoved, stochHasRemoved, stochValidSpan, ref stoch1Min, ref stoch1Max);
+                }
+
+                // 3) Stoch2
+                double stoch2Raw;
+                if (stoch1Count == kPeriod)
+                {
+                    double span = stoch1Max - stoch1Min;
+                    if (span > double.Epsilon)
+                    {
+                        stoch2Raw = 100.0 * (stoch1 - stoch1Min) / span;
+                    }
+                    else
+                    {
+                        stoch2Raw = double.IsNaN(stoch2Ema) ? stoch1 : stoch2Ema;
+                    }
+
+                    stoch2Raw = Clamp100(stoch2Raw);
+                }
+                else
+                {
+                    stoch2Raw = stoch1;
+                }
+
+                // 4) Final Smooth
+                double stc = double.NaN;
+                if (!double.IsNaN(stoch2Raw))
+                {
+                    stc = ApplySmoothing(stoch2Raw, smoothing, dAlpha, ref stoch2Ema, ref prevStc);
+                }
+
+                output[i] = stc;
+            }
+        }
+        finally
+        {
+            if (rentedMacd != null)
+            {
+                ArrayPool<double>.Shared.Return(rentedMacd);
+            }
+
+            if (rentedStoch1 != null)
+            {
+                ArrayPool<double>.Shared.Return(rentedStoch1);
+            }
+        }
+    }
+
+    public static (TSeries Results, Stc Indicator) Calculate(TSeries source, int kPeriod = 10, int dPeriod = 3, int fastLength = 23, int slowLength = 50, StcSmoothing smoothing = StcSmoothing.Ema)
+    {
+        var indicator = new Stc(kPeriod, dPeriod, fastLength, slowLength, smoothing);
+        TSeries results = indicator.Update(source);
+        return (results, indicator);
+    }
+}

lib/oscillators/stc/stc.md

@@ -0,0 +1,180 @@
+# STC: Schaff Trend Cycle
+
+The Schaff Trend Cycle is a cyclometric oscillator that applies double-Stochastic normalization to MACD, extracting the cyclical phase hidden within the trend itself. The recursive normalization produces a bounded 0–100 output that reaches extremes earlier than raw MACD while suppressing Stochastic jitter. Developed for currency markets, STC's tendency to flatline at 0 or 100 during strong trends signals continuation rather than reversal — a feature that distinguishes it from conventional momentum oscillators. Output converges toward a square wave in steady-state trending conditions.
+
+## Historical Context
+
+Doug Schaff developed STC in the 1990s while trading currency markets. His diagnosis: MACD identified trends correctly but with unacceptable lag — by signal time, much of the move had elapsed. The Stochastic oscillator was fast but noisy, generating false signals in trending markets. Schaff's synthesis recognized that trends themselves move in cycles. Rather than choosing between lagging trend detection and noisy cycle extraction, he piped MACD through the Stochastic twice. The first pass normalizes MACD within its recent range, collapsing the unbounded trend signal into a 0–100 band. The second pass normalizes the smoothed first pass, further compressing the cycle information and creating a self-normalizing oscillator. The double normalization acts as a nonlinear filter that amplifies transitions and suppresses noise during sustained moves. STC found particular traction in forex trading where the 24-hour market rewarded speed advantages over MACD. The flatline behavior at extremes — initially dismissed as a limitation — became recognized as a defining feature: sustained 0 or 100 readings indicate trend continuation with high confidence, equivalent to a digital "trend on" signal.
+
+## Architecture & Physics
+
+### 1. MACD Construction
+
+Fast and slow EMAs generate the raw trend signal:
+
+$$\alpha_f = \frac{2}{\text{fastLength} + 1}, \quad \alpha_s = \frac{2}{\text{slowLength} + 1}$$
+
+$$\text{EMA}_{f,t} = \alpha_f \cdot P_t + (1 - \alpha_f) \cdot \text{EMA}_{f,t-1}$$
+
+$$\text{EMA}_{s,t} = \alpha_s \cdot P_t + (1 - \alpha_s) \cdot \text{EMA}_{s,t-1}$$
+
+$$\text{MACD}_t = \text{EMA}_{f,t} - \text{EMA}_{s,t}$$
+
+### 2. First Stochastic (%K₁)
+
+Normalize MACD within its recent $k$-bar range:
+
+$$\%K_1 = 100 \times \frac{\text{MACD}_t - \min(\text{MACD}_{t-k+1:t})}{\max(\text{MACD}_{t-k+1:t}) - \min(\text{MACD}_{t-k+1:t})}$$
+
+When $\max = \min$ (flat MACD), $\%K_1$ holds its previous value. This collapses the unbounded MACD into [0, 100].
+
+### 3. First Smoothing (%D₁)
+
+EMA smooth the first Stochastic to reduce whipsaw:
+
+$$\alpha_d = \frac{2}{d\text{Period} + 1}$$
+
+$$\%D_{1,t} = \alpha_d \cdot \%K_{1,t} + (1 - \alpha_d) \cdot \%D_{1,t-1}$$
+
+### 4. Second Stochastic (%K₂)
+
+Apply Stochastic normalization again to %D₁, using the same $k$-bar window:
+
+$$\%K_2 = 100 \times \frac{\%D_{1,t} - \min(\%D_{1,t-k+1:t})}{\max(\%D_{1,t-k+1:t}) - \min(\%D_{1,t-k+1:t})}$$
+
+This second pass further compresses the signal, amplifying transitions between trend phases.
+
+### 5. Final Smoothing
+
+Apply selected smoothing method to %K₂:
+
+$$\text{STC}_t = \text{Smooth}(\%K_{2,t})$$
+
+Smoothing options:
+
+- **None:** Raw %K₂ output
+- **EMA:** Standard EMA smoothing with $\alpha_d$
+- **Sigmoid:** $S(x) = \frac{100}{1 + e^{-0.1(x - 50)}}$ — S-curve compression
+- **Digital:** Threshold at 50 → output snaps to 0 or 100 (square wave)
+
+### 6. Complexity
+
+- **Time:** $O(k)$ per bar for min/max scanning over both Stochastic windows
+- **Space:** $O(k)$ — two ring buffers of size kPeriod (MACD values and %D₁ values)
+- **Warmup:** slowLength + kPeriod bars before output stabilizes
+
+## Mathematical Foundation
+
+### Parameters
+
+| Symbol | Parameter | Default | Constraint |
+|--------|-----------|---------|------------|
+| $k$ | kPeriod | 10 | $k \geq 2$ |
+| $d$ | dPeriod | 3 | $d \geq 1$ |
+| $f$ | fastLength | 23 | $f \geq 1$ |
+| $s$ | slowLength | 50 | $s > f$ |
+| — | smoothing | EMA | None / EMA / Sigmoid / Digital |
+
+### Pseudo-code
+
+```
+Initialize:
+  ema_fast = ema_slow = first price
+  α_f = 2 / (fastLength + 1)
+  α_s = 2 / (slowLength + 1)
+  α_d = 2 / (dPeriod + 1)
+  macd_buf = RingBuffer(kPeriod)
+  d1_buf = RingBuffer(kPeriod)
+  %D₁ = 0
+  bar_count = 0
+
+On each bar (price, isNew):
+  if !isNew: restore previous state
+
+  // Step 1: MACD
+  ema_fast = FMA(ema_fast, 1 - α_f, α_f × price)
+  ema_slow = FMA(ema_slow, 1 - α_s, α_s × price)
+  macd = ema_fast - ema_slow
+
+  // Step 2: First Stochastic
+  macd_buf.Add(macd)
+  macd_max = Max(macd_buf)
+  macd_min = Min(macd_buf)
+  range1 = macd_max - macd_min
+  %K₁ = range1 > 0 ? 100 × (macd - macd_min) / range1 : prev_%K₁
+
+  // Step 3: First Smoothing
+  %D₁ = FMA(%D₁, 1 - α_d, α_d × %K₁)
+
+  // Step 4: Second Stochastic
+  d1_buf.Add(%D₁)
+  d1_max = Max(d1_buf)
+  d1_min = Min(d1_buf)
+  range2 = d1_max - d1_min
+  %K₂ = range2 > 0 ? 100 × (%D₁ - d1_min) / range2 : prev_%K₂
+
+  // Step 5: Final Smoothing
+  switch smoothing:
+    None:    STC = %K₂
+    EMA:     STC = FMA(prev_STC, 1 - α_d, α_d × %K₂)
+    Sigmoid: STC = 100 / (1 + exp(-0.1 × (%K₂ - 50)))
+    Digital: STC = %K₂ ≥ 50 ? 100 : 0
+
+  output = Clamp(STC, 0, 100)
+```
+
+### Signal Characteristics
+
+| Condition | Output Behavior |
+|-----------|----------------|
+| Strong uptrend | Flatlines at 100 (square wave high) |
+| Strong downtrend | Flatlines at 0 (square wave low) |
+| Trend transition | Rapid swing between extremes |
+| Ranging market | Oscillates mid-range (25–75) |
+| Above 75 | Overbought zone |
+| Below 25 | Oversold zone |
+
+### Cycle Length Heuristic
+
+Setting $k \approx f/2$ targets the half-cycle of the MACD's dominant frequency, aligning the Stochastic window with the trend's internal oscillation period.
+
+### SIMD Applicability
+
+The recursive EMA dependencies and sequential min/max ring buffer updates prevent SIMD vectorization of the streaming path. The `Calculate(Span)` path can parallelize independent MACD computations but must serialize the double-Stochastic pipeline.
+
+## Performance Profile
+
+### Operation Count (Streaming Mode)
+
+| Operation | Count per bar | Notes |
+|-----------|--------------|-------|
+| Fast EMA | ~3 | 1 FMA + 1 MUL |
+| Slow EMA | ~3 | 1 FMA + 1 MUL |
+| MACD subtraction | ~1 | 1 SUB |
+| Ring buffer add (MACD) | ~1 | 1 write + index update |
+| Min/Max scan (MACD buf) | ~2k | Linear scan of k elements × 2 (min + max) |
+| First Stochastic (%K₁) | ~4 | 1 SUB + 1 DIV + 1 MUL + 1 branch |
+| First EMA smoothing (%D₁) | ~3 | 1 FMA + 1 MUL |
+| Ring buffer add (%D₁) | ~1 | 1 write + index update |
+| Min/Max scan (%D₁ buf) | ~2k | Linear scan of k elements × 2 |
+| Second Stochastic (%K₂) | ~4 | 1 SUB + 1 DIV + 1 MUL + 1 branch |
+| Final smoothing (EMA) | ~3 | 1 FMA + 1 MUL |
+| Clamp | ~2 | 2 comparisons |
+| **Total (k=10 default)** | **~65** | **O(k) dominated by dual min/max scans** |
+| **Total (k=50 worst)** | **~225** | **Linear growth with kPeriod** |
+
+### Batch Mode (SIMD Analysis)
+
+| Aspect | Assessment |
+|--------|------------|
+| SIMD vectorizable | No: recursive EMAs + sequential ring buffer min/max prevent vectorization |
+| Bottleneck | Dual min/max scans over ring buffers (2×k comparisons per bar) |
+| Parallelism | MACD EMA computation is independent of Stochastic pipeline but still sequential IIR |
+| Memory | O(k): two ring buffers of kPeriod doubles + 6 scalar EMA states (~200 bytes at k=10) |
+| Throughput | Moderate; faster than HT family (no transcendentals) but slower than pure IIR (min/max scans) |
+
+## Resources
+
+- Schaff, D. — "Schaff Trend Cycle" (currency trading methodology, 1990s)
+- PineScript reference: `stc.pine` in indicator directory
+- Ehlers, J.F. — *Cybernetic Analysis for Stocks and Futures* (cycle extraction theory)

lib/oscillators/stc/stc.pine

@@ -0,0 +1,76 @@
+// The MIT License (MIT)
+// © mihakralj
+//@version=6
+indicator("Schaff Trend Cycle (STC)", "STC", overlay=false)
+
+ema(series float source,simple int period=0,simple float alpha=0)=>
+    if alpha<=0 and period<=0
+        runtime.error("Alpha or period must be provided")
+    float a=alpha>0?alpha:2.0/(math.max(period,1)+1)
+    var float raw_ema=na
+    var float ema=na
+    var float e=1.0 
+    var bool warmup=true
+    if not na(source)
+        if na(raw_ema)
+            raw_ema:=0
+            ema:=source
+        else
+            raw_ema:=a*(source-raw_ema)+raw_ema
+            if warmup
+                e*=(1-a)
+                float c=1.0/(1.0-e)
+                ema:=c*raw_ema
+                if e<=1e-10
+                    warmup:=false
+            else
+                ema:=raw_ema
+    ema
+
+//@function Calculates the Schaff Trend Cycle (STC) indicator
+//@param source Input price series
+//@param cycleLength Main cycle length parameter for lookback periods
+//@param fastLength Period for fast EMA calculation
+//@param slowLength Period for slow EMA calculation
+//@param smoothingType Type of smoothing (0:none, 1:ema, 2:sigmoid, 3:digital)
+//@returns Smoothed STC value
+stc(series float source, simple int cycleLength, simple int fastLength, simple int slowLength, simple int smoothingType = 1) =>
+    float fast_ema = ema(source, fastLength)
+    float slow_ema = ema(source, slowLength)
+    float macdLine = fast_ema - slow_ema
+
+    h1 = ta.highest(macdLine, cycleLength)
+    l1 = ta.lowest(macdLine, cycleLength)
+    float stoch1_raw = (h1 - l1) > 0 ? 100 * (macdLine - l1) / (h1 - l1) : 0
+    float stoch1 = ema(stoch1_raw, 3)
+    h2 = ta.highest(stoch1, cycleLength)
+    l2 = ta.lowest(stoch1, cycleLength)
+    float stoch2_raw = (h2 - l2) > 0 ? 100 * (stoch1 - l2) / (h2 - l2) : 0
+
+    // Second-stage IIR smoothing: PFF = PFF[1] + 0.5 * (Frac2 - PFF[1])
+    var float stoch2 = na
+    stoch2 := na(stoch2[1]) ? stoch2_raw : stoch2[1] + 0.5 * (stoch2_raw - stoch2[1])
+
+    float stcValue = stoch2
+    if smoothingType == 1
+        stcValue := ema(stoch2, 3)
+    else if smoothingType == 2
+        stcValue := 100 / (1 + math.exp(-0.1 * (stcValue - 50)))
+    else if smoothingType == 3
+        stcValue := stcValue > 75 ? 100 : stcValue < 25 ? 0 : stcValue[1]
+    stcValue
+
+// ---------- Main loop ----------
+
+// Inputs
+i_source = input.source(close, title="Source")
+i_cycleLength = input.int(10, title="Cycle Length", minval=2)
+i_fastLength = input.int(23, title="Fast Length", minval=2)
+i_slowLength = input.int(50, title="Slow Length", minval=2)
+i_smoothingType = input.int(1, title="Smoothing", minval=0, maxval=3, tooltip="0: none, 1:ema, 2:sigmoid, 3:digital")
+
+// Calculation
+stcValue = stc(i_source, i_cycleLength, i_fastLength, i_slowLength, i_smoothingType)
+
+// Plot
+plot(stcValue, "STC", color=color.yellow, linewidth=2)