MACD and RSI

2026-08-12 15:48:05 +00:00 · 2022-04-27 18:32:22 -07:00
parent 707454a6c1
commit d894d259c3
3 changed files with 172 additions and 0 deletions
@@ -0,0 +1,46 @@
+namespace QuanTAlib;
+using System;
+
+/* <summary>
+MACD: Moving Average Convergence/Divergence
+    Moving average convergence divergence (MACD) is a trend-following momentum
+    indicator that shows the relationship between two moving averages of a series.
+    The MACD is calculated by subtracting the 26-period exponential moving average (EMA)
+    from the 12-period EMA. MACD Signal is 9-day EMA of MACD.
+
+Sources:
+    https://www.investopedia.com/terms/m/macd.asp
+    https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/macd
+
+</summary> */
+
+public class MACD_Series : Single_TSeries_Indicator
+{
+    private EMA_Series _TSslow;
+    private EMA_Series _TSfast;
+    private SUB_Series _TSmacd;
+    public EMA_Series Signal { get; }
+
+    public MACD_Series(TSeries source, int slow = 26, int fast = 12, int signal = 9, bool useNaN = false)
+        : base(source, period: 0, useNaN)
+    {
+        _TSslow = new(source: source, period: slow, useNaN: false);
+        _TSfast = new(source: source, period: fast, useNaN: false);
+        _TSmacd = new(_TSfast, _TSslow);
+        Signal = new(source: _TSmacd, period: signal, useNaN: useNaN);
+
+        if (source.Count > 0) { base.Add(_TSmacd); }
+    }
+    public override void Add((System.DateTime t, double v) TValue, bool update)
+    {
+        double _macd;
+        if (update)
+        {
+            _TSslow.Add(TValue, true);
+            _TSfast.Add(TValue, true);
+        }
+        _macd = this._TSmacd[(this.Count < this._TSmacd.Count) ? this.Count : this._TSmacd.Count - 1].v;
+        var result = (TValue.t, _macd);
+        base.Add(result, update);
+    }
+}
@@ -0,0 +1,73 @@
+namespace QuanTAlib;
+using System;
+
+/* <summary>
+RSI: Relative Strength Index
+    Created by J. Welles Wilder, the Relative Strength Index measures strength
+    of the winning/losing streak over N lookback periods on a scale of 0 to 100,
+    to depict overbought and oversold conditions.
+
+Sources:
+    https://www.investopedia.com/terms/r/rsi.asp
+
+</summary> */
+
+public class RSI_Series : Single_TSeries_Indicator
+{
+    private readonly System.Collections.Generic.List<double> _gain = new();
+    private readonly System.Collections.Generic.List<double> _loss = new();
+    double _avgGain = 0;
+    double _avgLoss = 0;
+    double _lastValue = 0;
+    double _lastlastValue = 0;
+
+    public RSI_Series(TSeries source, int period = 10, bool useNaN = false) : base(source, period: period, useNaN: useNaN)
+    { if (source.Count > 0) { base.Add(source); } }
+
+    public override void Add((System.DateTime t, double v) TValue, bool update)
+    {
+        int i = this.Count;
+        double _rsi = 0;
+        if (update) { _lastValue = _lastlastValue; }
+        if (i == 0) { _lastValue = TValue.v; }
+
+        double _gainval = (TValue.v > _lastValue) ? TValue.v - _lastValue : 0;
+        if (update) { _gain[_gain.Count - 1] = _gainval; } else { _gain.Add(_gainval); }
+        if (_gain.Count > this._p) { _gain.RemoveAt(0); }
+
+        double _lossval = (TValue.v < _lastValue) ? _lastValue - TValue.v : 0;
+        if (update) { _loss[_loss.Count - 1] = _lossval; } else { _loss.Add(_lossval); }
+        if (_loss.Count > this._p) { _loss.RemoveAt(0); }
+
+        _lastlastValue = _lastValue;
+        _lastValue = TValue.v;
+
+        // calculate RSI
+        if (i > _p)
+        {
+            _avgGain = ((_avgGain * (_p - 1)) + _gain[_gain.Count - 1]) / _p;
+            _avgLoss = ((_avgLoss * (_p - 1)) + _loss[_loss.Count - 1]) / _p;
+            if (_avgLoss > 0) {
+                double rs = _avgGain / _avgLoss;
+                _rsi = 100 - (100 / (1 + rs));
+            }
+            else { _rsi = 100; }
+        }
+        // initialize average gain
+        else
+        {
+            double _sumGain = 0;
+            for (int p = 0; p < _gain.Count; p++) { _sumGain += _gain[p]; }
+            double _sumLoss = 0;
+            for (int p = 0; p < _loss.Count; p++) { _sumLoss += _loss[p]; }
+
+            _avgGain = _sumGain / _gain.Count;
+            _avgLoss = _sumLoss / _loss.Count;
+
+            _rsi = (_avgLoss > 0) ? 100 - (100 / (1 + (_avgGain / _avgLoss))) : 100;
+        }
+
+        var result = (TValue.t, (this.Count < this._p && this._NaN) ? double.NaN : _rsi);
+        base.Add(result, update);
+    }
+}