Русский RU
Открыть на GitHub

Стратегия Two MA RSI

Обзор

Стратегия Two MA RSI — это перенос советника MetaTrader «2MA_RSI». Она использует пересечение быстрой и медленной экспоненциальных скользящих средних (EMA), дополненное фильтром из индекса относительной силы (RSI). Размер позиции определяется модулем мартингейла: после убыточной сделки объём следующей заявки увеличивается. Реализация на StockSharp работает только по завершённым свечам и воспроизводит исходные уровни тейк-профита и стоп-лосса, заданные в пунктах.

Данные и индикаторы

  • Подписка ведётся на одну серию свечей CandleType (по умолчанию пятиминутные свечи).
  • На каждой закрытой свече пересчитываются три индикатора:
    • EMA с периодом FastLength по цене закрытия.
    • EMA с периодом SlowLength.
    • RSI с периодом RsiLength.
  • Значения EMA предыдущих свечей сохраняются внутри стратегии — доступ к буферам индикаторов не требуется.

Логика входа

  1. Анализируется только закрытая свеча, что исключает повторные сигналы внутри бара.
  2. Позиция должна отсутствовать (Position == 0).
  3. Вход в лонг:
    • Быстрая EMA пересекает медленную снизу вверх (текущее значение EMA_fast больше EMA_slow, тогда как на прошлой свече EMA_fast < EMA_slow).
    • RSI опускается ниже порога RsiOversold, подтверждая перепроданность.
  4. Вход в шорт:
    • Быстрая EMA пересекает медленную сверху вниз при условии EMA_fast < EMA_slow на текущей свече и EMA_fast > EMA_slow на предыдущей.
    • RSI превышает порог RsiOverbought, что трактуется как перекупленность.
  5. При выполнении условий отправляется рыночная заявка с объёмом, рассчитанным модулем мартингейла.

Логика выхода

  • После открытия позиции сразу рассчитываются уровни стоп-лосса и тейк-профита. Расстояния задаются в пунктах и переводятся в цену через PriceStep инструмента:
    • Лонг:
      • Stop Loss = цена входа - StopLossPoints * PriceStep.
      • Take Profit = цена входа + TakeProfitPoints * PriceStep.
    • Шорт:
      • Stop Loss = цена входа + StopLossPoints * PriceStep.
      • Take Profit = цена входа - TakeProfitPoints * PriceStep.
  • Сделка закрывается только достижением защитных уровней. На следующей свече проверяется диапазон High/Low, и при касании соответствующего уровня вызывается ClosePosition().
  • При одновременном попадании стопа и цели в диапазон свечи приоритет остаётся консервативным: сперва проверяется стоп-лосс, затем тейк-профит, как и в оригинальном роботе.

Управление объёмом и мартингейл

  1. Базовый объём вычисляется как floor(balance / BalanceDivider) * VolumeStep. Используется текущая стоимость портфеля (Portfolio.CurrentValue, при необходимости BeginValue). Объём не опускается ниже шага объёма инструмента.
  2. После каждой убыточной фиксации счётчик мартингейла увеличивается на единицу, но не превышает MaxDoublings. Следующая заявка умножается на 2^stage.
  3. Любая прибыльная сделка или достижение максимального числа удвоений сбрасывает счётчик в ноль, возвращая базовый объём.
  4. Если MaxDoublings меньше либо равно нулю, увеличение объёма отключено и всегда используется базовый объём.

Дополнительные особенности

  • Стратегия хранит необходимые прошлые значения EMA и не запрашивает индикаторы с произвольным сдвигом.
  • Сделки совершаются только при готовности индикаторов и разрешённой торговле (IsFormedAndOnlineAndAllowTrading).
  • На график выводятся свечи, собственные сделки и линии трёх индикаторов для визуального контроля.

Параметры

Параметр Описание Значение по умолчанию
FastLength Период быстрой EMA. 5
SlowLength Период медленной EMA. 20
RsiLength Количество свечей в расчёте RSI. 14
RsiOverbought Уровень RSI для поиска шорт-сигналов. 70
RsiOversold Уровень RSI для допуска лонг-сигналов. 30
StopLossPoints Размер стоп-лосса в шагах цены. 500
TakeProfitPoints Размер тейк-профита в шагах цены. 1500
BalanceDivider Делитель баланса для расчёта базового объёма. 1000
MaxDoublings Максимальное число последовательных удвоений. 1
CandleType Тип свечей, с которыми работает стратегия. Таймфрейм 5 минут

Примечания по использованию

  • Необходимо, чтобы у инструмента были заданы PriceStep и VolumeStep, иначе пересчёт пунктов и объёма может быть некорректным.
  • Выходы выполняются рыночными заявками, поэтому фактическое проскальзывание возможно, хотя логика определения стопов и целей сохранена.
  • Python-версия не предоставляется — создан только C# вариант в соответствии с требованиями задания.
using System;
using System.Linq;
using System.Collections.Generic;
using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;



/// <summary>
/// Moving average crossover strategy with RSI confirmation and martingale sizing.
/// </summary>
public class TwoMaRsiStrategy : Strategy
{
	private readonly StrategyParam<int> _fastLength;
	private readonly StrategyParam<int> _slowLength;
	private readonly StrategyParam<int> _rsiLength;
	private readonly StrategyParam<decimal> _rsiOverbought;
	private readonly StrategyParam<decimal> _rsiOversold;
	private readonly StrategyParam<decimal> _stopLossPoints;
	private readonly StrategyParam<decimal> _takeProfitPoints;
	private readonly StrategyParam<decimal> _balanceDivider;
	private readonly StrategyParam<int> _maxDoublings;
	private readonly StrategyParam<DataType> _candleType;

	private ExponentialMovingAverage _fastEma;
	private ExponentialMovingAverage _slowEma;
	private RelativeStrengthIndex _rsi;

	private decimal? _previousFast;
	private decimal? _previousSlow;
	private decimal _entryPrice;
	private decimal _stopPrice;
	private decimal _takeProfitPrice;
	private int _martingaleStage;
	private bool _isClosing;

	/// <summary>
	/// Initializes a new instance of the <see cref="TwoMaRsiStrategy"/> class.
	/// </summary>
	public TwoMaRsiStrategy()
	{
		_fastLength = Param(nameof(FastLength), 5)
			.SetDisplay("Fast EMA Length", "Length of the fast exponential moving average", "Indicators")
			
			.SetOptimize(2, 20, 1);

		_slowLength = Param(nameof(SlowLength), 20)
			.SetDisplay("Slow EMA Length", "Length of the slow exponential moving average", "Indicators")
			
			.SetOptimize(10, 60, 5);

		_rsiLength = Param(nameof(RsiLength), 14)
			.SetDisplay("RSI Length", "Number of bars for the RSI calculation", "Indicators")
			
			.SetOptimize(5, 30, 1);

		_rsiOverbought = Param(nameof(RsiOverbought), 50m)
			.SetDisplay("RSI Overbought", "Upper RSI threshold for short entries", "Signals");

		_rsiOversold = Param(nameof(RsiOversold), 50m)
			.SetDisplay("RSI Oversold", "Lower RSI threshold for long entries", "Signals");

		_stopLossPoints = Param(nameof(StopLossPoints), 500m)
			.SetDisplay("Stop Loss (points)", "Stop loss distance in price steps", "Risk");

		_takeProfitPoints = Param(nameof(TakeProfitPoints), 1500m)
			.SetDisplay("Take Profit (points)", "Take profit distance in price steps", "Risk");

		_balanceDivider = Param(nameof(BalanceDivider), 1000m)
			.SetDisplay("Balance Divider", "Divides portfolio value to estimate base order volume", "Money Management");

		_maxDoublings = Param(nameof(MaxDoublings), 1)
			.SetDisplay("Max Doublings", "Maximum number of martingale doublings", "Money Management");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Primary candle series for the strategy", "General");
	}

	/// <summary>
	/// Fast EMA length.
	/// </summary>
	public int FastLength
	{
		get => _fastLength.Value;
		set => _fastLength.Value = value;
	}

	/// <summary>
	/// Slow EMA length.
	/// </summary>
	public int SlowLength
	{
		get => _slowLength.Value;
		set => _slowLength.Value = value;
	}

	/// <summary>
	/// RSI period.
	/// </summary>
	public int RsiLength
	{
		get => _rsiLength.Value;
		set => _rsiLength.Value = value;
	}

	/// <summary>
	/// Overbought threshold for RSI.
	/// </summary>
	public decimal RsiOverbought
	{
		get => _rsiOverbought.Value;
		set => _rsiOverbought.Value = value;
	}

	/// <summary>
	/// Oversold threshold for RSI.
	/// </summary>
	public decimal RsiOversold
	{
		get => _rsiOversold.Value;
		set => _rsiOversold.Value = value;
	}

	/// <summary>
	/// Stop loss distance expressed in price steps.
	/// </summary>
	public decimal StopLossPoints
	{
		get => _stopLossPoints.Value;
		set => _stopLossPoints.Value = value;
	}

	/// <summary>
	/// Take profit distance expressed in price steps.
	/// </summary>
	public decimal TakeProfitPoints
	{
		get => _takeProfitPoints.Value;
		set => _takeProfitPoints.Value = value;
	}

	/// <summary>
	/// Divider applied to the portfolio value to calculate the base order volume.
	/// </summary>
	public decimal BalanceDivider
	{
		get => _balanceDivider.Value;
		set => _balanceDivider.Value = value;
	}

	/// <summary>
	/// Maximum number of martingale doublings.
	/// </summary>
	public int MaxDoublings
	{
		get => _maxDoublings.Value;
		set => _maxDoublings.Value = value;
	}

	/// <summary>
	/// Candle data type used by the strategy.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_fastEma = null;
		_slowEma = null;
		_rsi = null;
		_previousFast = null;
		_previousSlow = null;
		_entryPrice = default;
		_stopPrice = default;
		_takeProfitPrice = default;
		_martingaleStage = 0;
		_isClosing = false;
	}

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

		_fastEma = new ExponentialMovingAverage
		{
			Length = FastLength
		};

		_slowEma = new ExponentialMovingAverage
		{
			Length = SlowLength
		};

		_rsi = new RelativeStrengthIndex
		{
			Length = RsiLength
		};

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

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

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

		if (Position == 0 && _isClosing)
		{
			_isClosing = false;
			_entryPrice = default;
			_stopPrice = default;
			_takeProfitPrice = default;
		}

		var fastResult = _fastEma.Process(candle);
		var slowResult = _slowEma.Process(candle);
		var rsiResult = _rsi.Process(candle);

		if (fastResult.IsEmpty || slowResult.IsEmpty || rsiResult.IsEmpty)
		{
			return;
		}

		if (!_fastEma.IsFormed || !_slowEma.IsFormed || !_rsi.IsFormed)
		{
			_previousFast = fastResult.GetValue<decimal>();
			_previousSlow = slowResult.GetValue<decimal>();
			return;
		}

		var fast = fastResult.GetValue<decimal>();
		var slow = slowResult.GetValue<decimal>();
		var rsi = rsiResult.GetValue<decimal>();
		var point = GetPoint();

		if (Position > 0)
		{
			var stopHit = candle.LowPrice <= _stopPrice;
			var takeHit = candle.HighPrice >= _takeProfitPrice;

			if (!_isClosing && stopHit)
			{
				_isClosing = true;
				ClosePosition();
				RegisterLoss();
			}
			else if (!_isClosing && takeHit)
			{
				_isClosing = true;
				ClosePosition();
				RegisterWin();
			}
		}
		else if (Position < 0)
		{
			var stopHit = candle.HighPrice >= _stopPrice;
			var takeHit = candle.LowPrice <= _takeProfitPrice;

			if (!_isClosing && stopHit)
			{
				_isClosing = true;
				ClosePosition();
				RegisterLoss();
			}
			else if (!_isClosing && takeHit)
			{
				_isClosing = true;
				ClosePosition();
				RegisterWin();
			}
		}
		else if (!_isClosing)
		{
			if (_previousFast is null || _previousSlow is null)
			{
				_previousFast = fast;
				_previousSlow = slow;
				return;
			}

			var prevFast = _previousFast.Value;
			var prevSlow = _previousSlow.Value;

			var crossUp = prevFast < prevSlow && fast > slow && rsi < RsiOversold;
			var crossDown = prevFast > prevSlow && fast < slow && rsi > RsiOverbought;

			if (crossUp)
			{
				var volume = CalculateOrderVolume();
				if (volume > 0m)
				{
					BuyMarket(volume);
					_entryPrice = candle.ClosePrice;
					_stopPrice = _entryPrice - StopLossPoints * point;
					_takeProfitPrice = _entryPrice + TakeProfitPoints * point;
				}
			}
			else if (crossDown)
			{
				var volume = CalculateOrderVolume();
				if (volume > 0m)
				{
					SellMarket(volume);
					_entryPrice = candle.ClosePrice;
					_stopPrice = _entryPrice + StopLossPoints * point;
					_takeProfitPrice = _entryPrice - TakeProfitPoints * point;
				}
			}
		}

		_previousFast = fast;
		_previousSlow = slow;
	}

	private decimal GetPoint()
	{
		var step = Security?.PriceStep ?? 1m;
		return step > 0m ? step : 1m;
	}

	private decimal CalculateOrderVolume()
	{
		var step = Security?.VolumeStep ?? 1m;
		if (step <= 0m)
			step = 1m;

		var baseVolume = step;
		var divider = BalanceDivider;
		var balance = Portfolio?.CurrentValue ?? Portfolio?.BeginValue ?? 0m;
		if (divider > 0m && balance > 0m)
		{
			var count = Math.Floor((double)(balance / divider));
			baseVolume = (decimal)count * step;
			if (baseVolume < step)
				baseVolume = step;
		}

		var multiplier = CalculateMartingaleMultiplier();
		var volume = baseVolume * multiplier;

		if (volume < step)
			volume = step;

		var ratio = volume / step;
		volume = Math.Ceiling(ratio) * step;

		return volume;
	}

	private decimal CalculateMartingaleMultiplier()
	{
		if (MaxDoublings <= 0 || _martingaleStage <= 0)
			return 1m;

		var stage = Math.Min(_martingaleStage, MaxDoublings);
		return (decimal)Math.Pow(2d, stage);
	}

	private void RegisterWin()
	{
		_martingaleStage = 0;
	}

	private void ClosePosition()
	{
		if (Position > 0)
			SellMarket(Position);
		else if (Position < 0)
			BuyMarket(-Position);
	}

	private void RegisterLoss()
	{
		if (MaxDoublings <= 0)
		{
			_martingaleStage = 0;
			return;
		}

		if (_martingaleStage < MaxDoublings)
		{
			_martingaleStage++;
		}
		else
		{
			_martingaleStage = 0;
		}
	}
}