RSI MA em RSI Estratégia Dupla

using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Dual moving averages calculated on top of RSI values.
/// Fast RSI MA crossing slow RSI MA generates entry signals.
/// </summary>
public class RsiMaOnRsiDualStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _fastRsiPeriod;
	private readonly StrategyParam<int> _slowRsiPeriod;
	private readonly StrategyParam<int> _maPeriod;

	private RelativeStrengthIndex _fastRsi;
	private RelativeStrengthIndex _slowRsi;
	private readonly Queue<decimal> _fastRsiHistory = new();
	private readonly Queue<decimal> _slowRsiHistory = new();

	private decimal? _previousFastMa;
	private decimal? _previousSlowMa;

	public RsiMaOnRsiDualStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(60).TimeFrame())
			.SetDisplay("Candle type", "Candles processed by the strategy.", "General");

		_fastRsiPeriod = Param(nameof(FastRsiPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("Fast RSI period", "Length of the fast RSI smoothing window.", "Indicators");

		_slowRsiPeriod = Param(nameof(SlowRsiPeriod), 28)
			.SetGreaterThanZero()
			.SetDisplay("Slow RSI period", "Length of the slow RSI smoothing window.", "Indicators");

		_maPeriod = Param(nameof(MaPeriod), 12)
			.SetGreaterThanZero()
			.SetDisplay("MA period", "Number of RSI values averaged by the smoothing moving average.", "Indicators");
	}

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public int FastRsiPeriod
	{
		get => _fastRsiPeriod.Value;
		set => _fastRsiPeriod.Value = value;
	}

	public int SlowRsiPeriod
	{
		get => _slowRsiPeriod.Value;
		set => _slowRsiPeriod.Value = value;
	}

	public int MaPeriod
	{
		get => _maPeriod.Value;
		set => _maPeriod.Value = value;
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_previousFastMa = null;
		_previousSlowMa = null;
		_fastRsiHistory.Clear();
		_slowRsiHistory.Clear();
		_fastRsi = null!;
		_slowRsi = null!;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_previousFastMa = null;
		_previousSlowMa = null;
		_fastRsiHistory.Clear();
		_slowRsiHistory.Clear();

		_fastRsi = new RelativeStrengthIndex { Length = FastRsiPeriod };
		_slowRsi = new RelativeStrengthIndex { Length = SlowRsiPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(_fastRsi, _slowRsi, ProcessCandle)
			.Start();

		var priceArea = CreateChartArea();
		if (priceArea != null)
		{
			DrawCandles(priceArea, subscription);
			DrawOwnTrades(priceArea);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastRsiValue, decimal slowRsiValue)
	{
		if (candle.State != CandleStates.Finished)
			return;

		_fastRsiHistory.Enqueue(fastRsiValue);
		_slowRsiHistory.Enqueue(slowRsiValue);
		while (_fastRsiHistory.Count > MaPeriod)
			_fastRsiHistory.Dequeue();
		while (_slowRsiHistory.Count > MaPeriod)
			_slowRsiHistory.Dequeue();

		if (!_fastRsi.IsFormed || !_slowRsi.IsFormed)
			return;

		if (_fastRsiHistory.Count < MaPeriod || _slowRsiHistory.Count < MaPeriod)
			return;

		// Calculate SMA of each RSI
		var fastSum = 0m;
		var fastHistory = _fastRsiHistory.ToArray();
		foreach (var v in fastHistory)
			fastSum += v;
		var fastMa = fastSum / MaPeriod;

		var slowSum = 0m;
		var slowHistory = _slowRsiHistory.ToArray();
		foreach (var v in slowHistory)
			slowSum += v;
		var slowMa = slowSum / MaPeriod;

		if (_previousFastMa is null || _previousSlowMa is null)
		{
			_previousFastMa = fastMa;
			_previousSlowMa = slowMa;
			return;
		}

		var crossUp = _previousFastMa < _previousSlowMa && fastMa > slowMa;
		var crossDown = _previousFastMa > _previousSlowMa && fastMa < slowMa;

		var volume = Volume;
		if (volume <= 0)
			volume = 1;

		if (crossUp)
		{
			if (Position <= 0)
				BuyMarket(volume);
		}
		else if (crossDown)
		{
			if (Position >= 0)
				SellMarket(volume);
		}

		_previousFastMa = fastMa;
		_previousSlowMa = slowMa;
	}
}

import clr

clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")

from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import RelativeStrengthIndex
from StockSharp.Algo.Strategies import Strategy

class rsi_ma_on_rsi_dual_strategy(Strategy):
    def __init__(self):
        super(rsi_ma_on_rsi_dual_strategy, self).__init__()

        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(60)))
        self._fast_rsi_period = self.Param("FastRsiPeriod", 14)
        self._slow_rsi_period = self.Param("SlowRsiPeriod", 28)
        self._ma_period = self.Param("MaPeriod", 12)

        self._fast_rsi_history = []
        self._slow_rsi_history = []
        self._prev_fast_ma = 0.0
        self._prev_slow_ma = 0.0
        self._has_prev = False

    @property
    def CandleType(self):
        return self._candle_type.Value

    @CandleType.setter
    def CandleType(self, value):
        self._candle_type.Value = value

    @property
    def FastRsiPeriod(self):
        return self._fast_rsi_period.Value

    @FastRsiPeriod.setter
    def FastRsiPeriod(self, value):
        self._fast_rsi_period.Value = value

    @property
    def SlowRsiPeriod(self):
        return self._slow_rsi_period.Value

    @SlowRsiPeriod.setter
    def SlowRsiPeriod(self, value):
        self._slow_rsi_period.Value = value

    @property
    def MaPeriod(self):
        return self._ma_period.Value

    @MaPeriod.setter
    def MaPeriod(self, value):
        self._ma_period.Value = value

    def OnReseted(self):
        super(rsi_ma_on_rsi_dual_strategy, self).OnReseted()
        self._fast_rsi_history = []
        self._slow_rsi_history = []
        self._prev_fast_ma = 0.0
        self._prev_slow_ma = 0.0
        self._has_prev = False

    def OnStarted2(self, time):
        super(rsi_ma_on_rsi_dual_strategy, self).OnStarted2(time)
        self._fast_rsi_history = []
        self._slow_rsi_history = []
        self._prev_fast_ma = 0.0
        self._prev_slow_ma = 0.0
        self._has_prev = False

        fast_rsi = RelativeStrengthIndex()
        fast_rsi.Length = self.FastRsiPeriod
        slow_rsi = RelativeStrengthIndex()
        slow_rsi.Length = self.SlowRsiPeriod

        subscription = self.SubscribeCandles(self.CandleType)
        subscription.Bind(fast_rsi, slow_rsi, self._process_candle).Start()

    def _process_candle(self, candle, fast_rsi_value, slow_rsi_value):
        if candle.State != CandleStates.Finished:
            return

        fast_val = float(fast_rsi_value)
        slow_val = float(slow_rsi_value)
        ma_len = self.MaPeriod

        self._fast_rsi_history.append(fast_val)
        self._slow_rsi_history.append(slow_val)
        while len(self._fast_rsi_history) > ma_len:
            self._fast_rsi_history.pop(0)
        while len(self._slow_rsi_history) > ma_len:
            self._slow_rsi_history.pop(0)

        if len(self._fast_rsi_history) < ma_len or len(self._slow_rsi_history) < ma_len:
            return

        fast_ma = sum(self._fast_rsi_history) / ma_len
        slow_ma = sum(self._slow_rsi_history) / ma_len

        if self._has_prev:
            cross_up = self._prev_fast_ma < self._prev_slow_ma and fast_ma > slow_ma
            cross_down = self._prev_fast_ma > self._prev_slow_ma and fast_ma < slow_ma

            if cross_up and self.Position <= 0:
                self.BuyMarket()
            elif cross_down and self.Position >= 0:
                self.SellMarket()

        self._prev_fast_ma = fast_ma
        self._prev_slow_ma = slow_ma
        self._has_prev = True

    def CreateClone(self):
        return rsi_ma_on_rsi_dual_strategy()