feat: add EEO (Ehlers Elegant Oscillator) - TASC Feb 2022

2026-08-18 18:48:05 +00:00 · 2026-03-17 14:18:57 -07:00
parent b9e6a70890
commit f7dcc20f7c
14 changed files with 1250 additions and 0 deletions
@@ -0,0 +1,157 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class EeoIndicatorTests
+{
+    [Fact]
+    public void EeoIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new EeoIndicator();
+
+        Assert.Equal(20, indicator.BandEdge);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("EEO - Ehlers Elegant Oscillator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void EeoIndicator_MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new EeoIndicator();
+
+        Assert.Equal(0, EeoIndicator.MinHistoryDepths);
+        Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void EeoIndicator_ShortName_IncludesBandEdgeAndSource()
+    {
+        var indicator = new EeoIndicator { BandEdge = 30 };
+
+        Assert.Contains("EEO", indicator.ShortName, StringComparison.Ordinal);
+        Assert.Contains("30", indicator.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void EeoIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new EeoIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
+        Assert.Contains("Eeo.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void EeoIndicator_Initialize_CreatesInternalIndicator()
+    {
+        var indicator = new EeoIndicator { BandEdge = 20 };
+
+        indicator.Initialize();
+
+        // After init, one line series should exist (EEO is single output)
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void EeoIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new EeoIndicator { BandEdge = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void EeoIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new EeoIndicator { BandEdge = 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 EeoIndicator_InternalIndicator_HandlesBarCorrection()
+    {
+        // Test the underlying Eeo with isNew=false (bar correction)
+        // Use zigzag data to avoid saturation
+        var ma = new Eeo(3);
+        double[] prices = [100, 102, 99, 103, 97, 104, 98, 105, 97, 106];
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < prices.Length; i++)
+        {
+            ma.Update(new TValue(now.AddMinutes(i).Ticks, prices[i]), isNew: true);
+        }
+
+        double beforeCorrection = ma.Last.Value;
+
+        // Correct last bar with a moderately different value
+        ma.Update(new TValue(now.AddMinutes(9).Ticks, 100), isNew: false);
+        double afterCorrection = ma.Last.Value;
+
+        Assert.NotEqual(beforeCorrection, afterCorrection);
+        Assert.True(double.IsFinite(afterCorrection));
+    }
+
+    [Fact]
+    public void EeoIndicator_DifferentSourceTypes()
+    {
+        foreach (SourceType sourceType in new[] { SourceType.Close, SourceType.Open, SourceType.High, SourceType.Low })
+        {
+            var indicator = new EeoIndicator();
+            indicator.Source = sourceType;
+            Assert.Equal(sourceType, indicator.Source);
+        }
+    }
+
+    [Fact]
+    public void EeoIndicator_MultipleHistoricalBars()
+    {
+        var indicator = new EeoIndicator { BandEdge = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
+            indicator.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        Assert.Equal(20, indicator.LinesSeries[0].Count);
+
+        // All values should be finite
+        for (int i = 0; i < 20; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(i)));
+        }
+    }
+
+    [Fact]
+    public void EeoIndicator_BandEdgeChange_UpdatesConfig()
+    {
+        var indicator = new EeoIndicator();
+        indicator.BandEdge = 25;
+        Assert.Equal(25, indicator.BandEdge);
+
+        indicator.BandEdge = 50;
+        Assert.Equal(50, indicator.BandEdge);
+    }
+}
@@ -0,0 +1,496 @@
+namespace QuanTAlib;
+
+public class EeoTests
+{
+    private const int DefaultBandEdge = 20;
+    private const double Tolerance = 1e-12;
+
+    private static TSeries MakeSeries(int count = 500)
+    {
+        var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.5, seed: 42);
+        var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        return bars.Close;
+    }
+
+    // ========== A) Constructor Validation ==========
+
+    [Fact]
+    public void Constructor_ZeroBandEdge_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Eeo(0));
+        Assert.Equal("bandEdge", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_OneBandEdge_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Eeo(1));
+        Assert.Equal("bandEdge", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_NegativeBandEdge_ThrowsArgumentOutOfRangeException()
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Eeo(-5));
+        Assert.Equal("bandEdge", ex.ParamName);
+    }
+
+    [Fact]
+    public void Constructor_ValidBandEdge_SetsNameAndWarmup()
+    {
+        var indicator = new Eeo(20);
+        Assert.Equal("Eeo(20)", indicator.Name);
+        Assert.Equal(70, indicator.WarmupPeriod); // 50 + 20
+    }
+
+    [Fact]
+    public void Constructor_BandEdgeTwo_IsValid()
+    {
+        var indicator = new Eeo(2);
+        Assert.Equal("Eeo(2)", indicator.Name);
+        Assert.Equal(52, indicator.WarmupPeriod); // 50 + 2
+    }
+
+    // ========== B) Basic Calculation ==========
+
+    [Fact]
+    public void Update_ReturnsTValue_WithValidProperties()
+    {
+        var indicator = new Eeo(DefaultBandEdge);
+        var input = new TValue(DateTime.UtcNow, 100.0);
+        TValue result = indicator.Update(input);
+
+        Assert.Equal(input.Time, result.Time);
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void Update_AfterWarmup_IsHotBecomesTrue()
+    {
+        var indicator = new Eeo(DefaultBandEdge);
+        Assert.False(indicator.IsHot);
+
+        for (int i = 0; i < 500; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.1));
+        }
+
+        Assert.True(indicator.IsHot);
+    }
+
+    [Fact]
+    public void Update_LastProperty_MatchesReturnValue()
+    {
+        var indicator = new Eeo(DefaultBandEdge);
+        var input = new TValue(DateTime.UtcNow, 42.0);
+        TValue result = indicator.Update(input);
+
+        Assert.Equal(result.Value, indicator.Last.Value, Tolerance);
+    }
+
+    // ========== C) State + Bar Correction ==========
+
+    [Fact]
+    public void IsNew_True_AdvancesState()
+    {
+        var indicator = new Eeo(10);
+
+        // Warm up past the threshold first
+        for (int i = 0; i < 65; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.5), isNew: true);
+        }
+
+        TValue r1 = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(80), 120.0), isNew: true);
+        TValue r2 = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(81), 80.0), isNew: true);
+
+        // Two very different bars after warmup must produce different results
+        Assert.NotEqual(r1.Value, r2.Value);
+    }
+
+    [Fact]
+    public void IsNew_False_RewritesCurrentBar()
+    {
+        var indicator = new Eeo(10);
+
+        // Use mixed zigzag data to avoid saturation
+        double[] prices = [100, 102, 99, 103, 97, 104, 98, 105, 97, 106,
+                           101, 103, 98, 104, 96, 105, 99, 107, 98, 108,
+                           100, 102, 99, 103, 97, 104, 98, 105, 97, 106,
+                           101, 103, 98, 104, 96, 105, 99, 107, 98, 108,
+                           100, 102, 99, 103, 97, 104, 98, 105, 97, 106,
+                           101, 103, 98, 104, 96, 105, 99, 107, 98, 108,
+                           100, 102, 99, 103, 97, 104, 98, 105, 97, 106];
+
+        for (int i = 0; i < prices.Length; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), prices[i]));
+        }
+
+        indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(prices.Length), 110.0), isNew: true);
+        double afterNew = indicator.Last.Value;
+
+        indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(prices.Length), 90.0), isNew: false);
+        double afterCorrection = indicator.Last.Value;
+
+        Assert.NotEqual(afterNew, afterCorrection);
+    }
+
+    [Fact]
+    public void IterativeCorrections_RestoreState()
+    {
+        var indicator = new Eeo(10);
+        TSeries data = MakeSeries();
+
+        for (int i = 0; i < 80; i++)
+        {
+            indicator.Update(data[i], isNew: true);
+        }
+
+        indicator.Update(data[80], isNew: true);
+
+        for (int j = 0; j < 5; j++)
+        {
+            indicator.Update(data[80], isNew: false);
+        }
+
+        double afterCorrections = indicator.Last.Value;
+
+        var fresh = new Eeo(10);
+        for (int i = 0; i <= 80; i++)
+        {
+            fresh.Update(data[i], isNew: true);
+        }
+
+        Assert.Equal(fresh.Last.Value, afterCorrections, Tolerance);
+    }
+
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var indicator = new Eeo(DefaultBandEdge);
+
+        for (int i = 0; i < 100; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
+        }
+
+        Assert.True(indicator.IsHot);
+
+        indicator.Reset();
+
+        Assert.False(indicator.IsHot);
+        Assert.Equal(default, indicator.Last);
+    }
+
+    // ========== D) Warmup/Convergence ==========
+
+    [Fact]
+    public void IsHot_FlipsAtCorrectTime()
+    {
+        var indicator = new Eeo(10);
+        int hotAt = -1;
+
+        for (int i = 0; i < 200; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.1));
+            if (indicator.IsHot && hotAt < 0)
+            {
+                hotAt = i;
+                break;
+            }
+        }
+
+        Assert.InRange(hotAt, 1, 200);
+    }
+
+    // ========== E) Robustness ==========
+
+    [Fact]
+    public void NaN_Input_UsesLastValidValue()
+    {
+        var indicator = new Eeo(10);
+
+        for (int i = 0; i < 70; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.1));
+        }
+
+        TValue nanResult = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(70), double.NaN));
+
+        Assert.True(double.IsFinite(nanResult.Value));
+    }
+
+    [Fact]
+    public void Infinity_Input_UsesLastValidValue()
+    {
+        var indicator = new Eeo(10);
+
+        for (int i = 0; i < 70; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.1));
+        }
+
+        TValue infResult = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(70), double.PositiveInfinity));
+        Assert.True(double.IsFinite(infResult.Value));
+    }
+
+    [Fact]
+    public void BatchNaN_DoesNotPropagate()
+    {
+        int bandEdge = 10;
+        double[] source = new double[100];
+        double[] output = new double[100];
+
+        for (int i = 0; i < 100; i++)
+        {
+            source[i] = 100.0 + i * 0.5;
+        }
+
+        source[50] = double.NaN;
+        source[51] = double.NaN;
+
+        Eeo.Batch(source, output, bandEdge);
+
+        for (int i = 0; i < 100; i++)
+        {
+            Assert.True(double.IsFinite(output[i]), $"Output[{i}] is not finite");
+        }
+    }
+
+    // ========== F) Consistency (4 API modes) ==========
+
+    [Fact]
+    public void AllModes_ProduceSameResult()
+    {
+        int bandEdge = 10;
+        TSeries data = MakeSeries();
+
+        // 1. Batch (TSeries)
+        TSeries batchResults = Eeo.Batch(data, bandEdge);
+        double expected = batchResults.Last.Value;
+
+        // 2. Span batch
+        var tValues = data.Values.ToArray();
+        var spanOutput = new double[tValues.Length];
+        Eeo.Batch(new ReadOnlySpan<double>(tValues), spanOutput, bandEdge);
+        double spanResult = spanOutput[^1];
+
+        // 3. Streaming
+        var streaming = new Eeo(bandEdge);
+        for (int i = 0; i < data.Count; i++)
+        {
+            streaming.Update(data[i]);
+        }
+        double streamingResult = streaming.Last.Value;
+
+        // 4. Eventing
+        var pubSource = new TSeries();
+        var eventBased = new Eeo(pubSource, bandEdge);
+        for (int i = 0; i < data.Count; i++)
+        {
+            pubSource.Add(data[i]);
+        }
+        double eventingResult = eventBased.Last.Value;
+
+        Assert.Equal(expected, spanResult, precision: 9);
+        Assert.Equal(expected, streamingResult, precision: 9);
+        Assert.Equal(expected, eventingResult, precision: 9);
+    }
+
+    // ========== G) Span API Tests ==========
+
+    [Fact]
+    public void SpanBatch_MismatchedLengths_ThrowsArgumentException()
+    {
+        double[] source = new double[10];
+        double[] output = new double[5];
+
+        var ex = Assert.Throws<ArgumentException>(() => Eeo.Batch(source, output, 5));
+        Assert.Equal("output", ex.ParamName);
+    }
+
+    [Fact]
+    public void SpanBatch_BandEdgeOne_ThrowsArgumentOutOfRangeException()
+    {
+        double[] source = new double[10];
+        double[] output = new double[10];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Eeo.Batch(source, output, 1));
+    }
+
+    [Fact]
+    public void SpanBatch_EmptyInput_ProducesEmptyOutput()
+    {
+        double[] source = Array.Empty<double>();
+        double[] output = Array.Empty<double>();
+        var ex = Record.Exception(() => Eeo.Batch(source, output, 10));
+        Assert.Null(ex);
+    }
+
+    [Fact]
+    public void SpanBatch_LargeData_DoesNotStackOverflow()
+    {
+        int size = 5000;
+        double[] source = new double[size];
+        double[] output = new double[size];
+
+        for (int i = 0; i < size; i++)
+        {
+            source[i] = 100.0 + i * 0.1;
+        }
+
+        Eeo.Batch(source, output, 20);
+
+        Assert.True(double.IsFinite(output[size - 1]));
+    }
+
+    // ========== H) Chainability ==========
+
+    [Fact]
+    public void Pub_EventFires_OnUpdate()
+    {
+        var indicator = new Eeo(DefaultBandEdge);
+        int eventCount = 0;
+
+        indicator.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
+
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
+        }
+
+        Assert.Equal(10, eventCount);
+    }
+
+    [Fact]
+    public void EventBased_Chaining_Works()
+    {
+        var source = new TSeries();
+        var indicator = new Eeo(source, 5);
+
+        source.Add(new TValue(DateTime.UtcNow, 100));
+        source.Add(new TValue(DateTime.UtcNow, 110));
+        source.Add(new TValue(DateTime.UtcNow, 120));
+
+        Assert.True(double.IsFinite(indicator.Last.Value));
+    }
+
+    [Fact]
+    public void Calculate_ReturnsHotIndicator()
+    {
+        TSeries data = MakeSeries();
+        (TSeries results, Eeo indicator) = Eeo.Calculate(data, DefaultBandEdge);
+
+        Assert.Equal(data.Count, results.Count);
+        Assert.True(indicator.IsHot);
+    }
+
+    [Fact]
+    public void StaticCalculate_MatchesInstance()
+    {
+        const int bandEdge = 10;
+        int count = 100;
+        var source = new TSeries();
+        var indicator = new Eeo(bandEdge);
+
+        for (int i = 0; i < count; i++)
+        {
+            source.Add(new TValue(DateTime.UtcNow.AddMinutes(i), i + 10));
+            indicator.Update(source.Last);
+        }
+
+        var staticResult = Eeo.Batch(source, bandEdge);
+
+        Assert.Equal(source.Count, staticResult.Count);
+        Assert.Equal(indicator.Last.Value, staticResult.Last.Value, 8);
+    }
+
+    // ========== EEO-specific: Oscillator behavior ==========
+
+    [Fact]
+    public void ConstantInput_OutputConvergesToZero()
+    {
+        var indicator = new Eeo(10);
+        double lastResult = double.NaN;
+
+        for (int i = 0; i < 300; i++)
+        {
+            TValue r = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
+            lastResult = r.Value;
+        }
+
+        // Constant input → deriv=0 → IFish(0)=0 → SS=0
+        Assert.Equal(0.0, lastResult, 1e-10);
+    }
+
+    [Fact]
+    public void TrendingInput_ProducesNonZero()
+    {
+        var indicator = new Eeo(10);
+        double lastResult = 0.0;
+
+        for (int i = 0; i < 100; i++)
+        {
+            TValue r = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 2.0));
+            lastResult = r.Value;
+        }
+
+        // Strong uptrend should produce non-zero EEO
+        Assert.NotEqual(0.0, lastResult);
+        Assert.True(double.IsFinite(lastResult));
+    }
+
+    [Fact]
+    public void Output_IsBounded()
+    {
+        var indicator = new Eeo(10);
+        TSeries data = MakeSeries(500);
+
+        for (int i = 0; i < data.Count; i++)
+        {
+            TValue r = indicator.Update(data[i]);
+            // EEO output should be approximately bounded [-1, +1]
+            // With SSF it might slightly exceed due to filter transients, but should be within [-1.5, +1.5]
+            Assert.InRange(r.Value, -1.5, 1.5);
+        }
+    }
+
+    [Fact]
+    public void IftOutput_IsSymmetric()
+    {
+        // EEO of ascending sequence should be opposite sign to EEO of descending sequence
+        var up = new Eeo(10);
+        var down = new Eeo(10);
+
+        for (int i = 0; i < 80; i++)
+        {
+            up.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
+            down.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 200.0 - i));
+        }
+
+        // Both should be finite and opposite in sign
+        Assert.True(double.IsFinite(up.Last.Value));
+        Assert.True(double.IsFinite(down.Last.Value));
+        Assert.True(up.Last.Value * down.Last.Value < 0, "Ascending and descending should produce opposite signs");
+    }
+
+    [Fact]
+    public void EeoProducesFiniteValues_OnGBMData()
+    {
+        var indicator = new Eeo(10);
+        TSeries data = MakeSeries(200);
+
+        int nonFiniteCount = 0;
+        for (int i = 0; i < data.Count; i++)
+        {
+            TValue r = indicator.Update(data[i]);
+            if (!double.IsFinite(r.Value))
+            {
+                nonFiniteCount++;
+            }
+        }
+
+        Assert.Equal(0, nonFiniteCount);
+    }
+}