Español ES
Ver en GitHub

Estrategia de Barra Interior Pequeña

Descripción general

La Estrategia de Barra Interior Pequeña busca un patrón compacto de barra interior seguido de un cambio de momentum entre dos velas consecutivas. El experto original de MetaTrader 5 fue traducido a la API de alto nivel de StockSharp y ahora opera solo en velas completadas. El enfoque está diseñado para traders que prefieren entradas de estilo ruptura activadas por fases de volatilidad comprimida.

Definición del patrón

La estrategia evalúa las dos velas completadas más recientes:

  1. Condición de barra interior – la última vela finalizada debe estar completamente contenida dentro del rango de la anterior.
  2. Filtro de ratio de rango – el rango de la barra madre (hace dos barras) debe ser al menos un múltiplo configurable del rango de la barra interior. El ratio predeterminado es 2:1.
  3. Filtros direccionales –
    • Una configuración larga requiere una barra interior alcista formándose en la mitad inferior de la barra madre junto con una barra madre bajista.
    • Una configuración corta requiere una barra interior bajista formándose en la mitad superior de la barra madre junto con una barra madre alcista.
  4. La inversión opcional intercambia las interpretaciones larga y corta mientras mantiene los mismos requisitos geométricos.

Manejo de posición

El parámetro OpenMode refleja el comportamiento del EA original:

  • AnySignal – envía una nueva orden de mercado en cada señal. Cuando existe una posición opuesta, se compensa parcialmente porque StockSharp usa cuentas de compensación.
  • SwingWithRefill – aplana la exposición opuesta antes de entrar y permite múltiples adiciones en la misma dirección.
  • SingleSwing – mantiene como máximo una operación direccional; las nuevas señales se ignoran mientras hay una posición alineada abierta.

Tanto las entradas largas como las cortas pueden habilitarse de forma independiente. El trading de inversión simplemente invierte qué configuración produce órdenes largas o cortas.

Parámetros

Nombre Predeterminado Descripción
CandleType Marco temporal de 1 hora Suscripción de velas usada para la detección de patrones.
RangeRatioThreshold 2.0 Ratio mínimo de rango madre a interior.
EnableLong true Permitir operaciones alcistas.
EnableShort true Permitir operaciones bajistas.
ReverseSignals false Intercambiar las direcciones de patrón larga y corta.
OpenMode SwingWithRefill Controla cómo se maneja la exposición existente ante una nueva señal.

Lógica de trading

  1. Suscribirse a la serie de velas configurada y esperar a las barras finalizadas.
  2. Mantener las últimas dos velas completadas para evaluar el patrón.
  3. Cuando el patrón y los filtros de ratio se alinean, determinar la señal direccional, aplicando opcionalmente la inversión.
  4. Confirmar que el trading está permitido (IsFormedAndOnlineAndAllowTrading) y que la dirección relevante está habilitada.
  5. Calcular el tamaño de la orden según el OpenMode seleccionado y enviar una orden de mercado usando el volumen base de la estrategia.
  6. Actualizar el historial de velas interno para que la vela más nueva forme parte del próximo ciclo de evaluación.

Notas de implementación

  • La estrategia usa StartProtection() para habilitar el gestor de riesgo integrado (sin valores predefinidos de stop o take-profit). Pueden añadirse filtros adicionales externamente si es necesario.
  • El estado del indicador no se almacena en colecciones; solo se mantienen las dos últimas velas según se requiere para el patrón.
  • El algoritmo depende únicamente de velas completadas, evitando cálculos intra-barra en línea con las mejores prácticas de la API de alto nivel.
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>
/// Implements the "Small Inside Bar" pattern strategy converted from MetaTrader 5.
/// The strategy searches for an inside bar with a small range compared to the mother bar
/// and opens positions following the direction of the pattern conditions.
/// </summary>
public class SmallInsideBarStrategy : Strategy
{
	/// <summary>
	/// Defines how the strategy manages simultaneous entries.
	/// </summary>
	public enum SmallInsideBarOpenModes
	{
		/// <summary>
		/// Open a new position on every signal without forcing opposite positions to close.
		/// </summary>
		AnySignal,

		/// <summary>
		/// Close opposite positions first and allow adding to the current swing direction.
		/// </summary>
		SwingWithRefill,

		/// <summary>
		/// Maintain a single position in the market and ignore additional entries while it is active.
		/// </summary>
		SingleSwing
	}

	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<decimal> _rangeRatioThreshold;
	private readonly StrategyParam<bool> _enableLong;
	private readonly StrategyParam<bool> _enableShort;
	private readonly StrategyParam<bool> _reverseSignals;
	private readonly StrategyParam<SmallInsideBarOpenModes> _openMode;

	private ICandleMessage _previousCandle;
	private ICandleMessage _twoBackCandle;

	/// <summary>
	/// Type of candles used for pattern detection.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Minimum ratio between the mother bar range and the inside bar range.
	/// </summary>
	public decimal RangeRatioThreshold
	{
		get => _rangeRatioThreshold.Value;
		set => _rangeRatioThreshold.Value = value;
	}

	/// <summary>
	/// Allow long trades.
	/// </summary>
	public bool EnableLong
	{
		get => _enableLong.Value;
		set => _enableLong.Value = value;
	}

	/// <summary>
	/// Allow short trades.
	/// </summary>
	public bool EnableShort
	{
		get => _enableShort.Value;
		set => _enableShort.Value = value;
	}

	/// <summary>
	/// Reverse long and short signals.
	/// </summary>
	public bool ReverseSignals
	{
		get => _reverseSignals.Value;
		set => _reverseSignals.Value = value;
	}

	/// <summary>
	/// Mode for handling position entries.
	/// </summary>
	public SmallInsideBarOpenModes OpenMode
	{
		get => _openMode.Value;
		set => _openMode.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of the strategy.
	/// </summary>
	public SmallInsideBarStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Time frame used for pattern detection", "General");

		_rangeRatioThreshold = Param(nameof(RangeRatioThreshold), 2.25m)
			.SetGreaterThanZero()
			.SetDisplay("Range Ratio", "Minimum mother-to-inside bar range ratio", "Pattern")
			
			.SetOptimize(1.5m, 3m, 0.25m);

		_enableLong = Param(nameof(EnableLong), true)
			.SetDisplay("Enable Long", "Allow bullish trades", "Trading");

		_enableShort = Param(nameof(EnableShort), true)
			.SetDisplay("Enable Short", "Allow bearish trades", "Trading");

		_reverseSignals = Param(nameof(ReverseSignals), false)
			.SetDisplay("Reverse Signals", "Invert long and short signals", "Trading");

		_openMode = Param(nameof(OpenMode), SmallInsideBarOpenModes.SwingWithRefill)
			.SetDisplay("Open Mode", "Position management mode", "Trading");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

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

		_previousCandle = null;
		_twoBackCandle = null;
	}

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

		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 (_previousCandle == null)
		{
			_previousCandle = candle;
			return;
		}

		if (_twoBackCandle == null)
		{
			_twoBackCandle = _previousCandle;
			_previousCandle = candle;
			return;
		}

		var insideHigh = _previousCandle.HighPrice;
		var insideLow = _previousCandle.LowPrice;
		var motherHigh = _twoBackCandle.HighPrice;
		var motherLow = _twoBackCandle.LowPrice;

		if (insideHigh <= insideLow || motherHigh <= motherLow)
		{
			ShiftHistory(candle);
			return;
		}

		if (!(insideHigh < motherHigh && insideLow > motherLow))
		{
			ShiftHistory(candle);
			return;
		}

		var insideRange = insideHigh - insideLow;
		var motherRange = motherHigh - motherLow;
		var ratio = insideRange == 0 ? decimal.MaxValue : motherRange / insideRange;

		if (ratio <= RangeRatioThreshold)
		{
			ShiftHistory(candle);
			return;
		}

		var midpoint = (motherHigh + motherLow) / 2m;

		var bullishInside = _previousCandle.ClosePrice > _previousCandle.OpenPrice && insideHigh < midpoint && _twoBackCandle.ClosePrice < _twoBackCandle.OpenPrice;
		var bearishInside = _previousCandle.ClosePrice < _previousCandle.OpenPrice && insideLow < midpoint && _twoBackCandle.ClosePrice > _twoBackCandle.OpenPrice;

		if (ReverseSignals)
		{
			(bullishInside, bearishInside) = (bearishInside, bullishInside);
		}

		var shouldOpenLong = bullishInside && EnableLong;
		var shouldOpenShort = bearishInside && EnableShort;

		if (shouldOpenLong)
		{
			var volume = CalculateOrderVolume(true);

			if (volume > 0)
				BuyMarket(volume);
		}

		if (shouldOpenShort)
		{
			var volume = CalculateOrderVolume(false);

			if (volume > 0)
				SellMarket(volume);
		}

		ShiftHistory(candle);
	}

	private decimal CalculateOrderVolume(bool isLong)
	{
		var baseVolume = Volume;

		if (baseVolume <= 0)
			return 0;

		var position = Position;

		if (isLong)
		{
			if (OpenMode == SmallInsideBarOpenModes.SingleSwing && position > 0)
				return 0;

			if (position < 0 && OpenMode != SmallInsideBarOpenModes.AnySignal)
				baseVolume += Math.Abs(position);
		}
		else
		{
			if (OpenMode == SmallInsideBarOpenModes.SingleSwing && position < 0)
				return 0;

			if (position > 0 && OpenMode != SmallInsideBarOpenModes.AnySignal)
				baseVolume += Math.Abs(position);
		}

		return baseVolume;
	}

	private void ShiftHistory(ICandleMessage candle)
	{
		// Keep track of the last two finished candles for pattern evaluation.
		_twoBackCandle = _previousCandle;
		_previousCandle = candle;
	}
}