Español ES
Ver en GitHub

Estrategia JB

Resumen

La estrategia JB procede de un asesor experto de fxDreema que combina filtros de tendencia de largo plazo, confirmación de impulso y rupturas de volatilidad:

  • Filtro de tendencia: exige que el cierre de la vela anterior permanezca por encima (largos) o por debajo (cortos) de una media móvil simple de 100 periodos.
  • Filtro de impulso: confirma la dirección con un Force Index de 100 periodos (positivo para largos, negativo para cortos).
  • Disparador de volatilidad: entra cuando el cierre anterior perfora la banda de Bollinger correspondiente (20 periodos, desviación 2,0).
  • Gestión de posición: aumenta el volumen de la orden con un multiplicador de estilo martingala después de un ciclo perdedor y vuelve al tamaño base después de ciclos rentables.
  • Regla de salida: cierra todas las posiciones abiertas cuando el beneficio no realizado medio por contrato alcanza un objetivo monetario configurable.

Parámetros

Nombre Descripción
SmaPeriod Longitud del filtro de tendencia SMA. Predeterminado: 100.
ForcePeriod Longitud del indicador Force Index. Predeterminado: 100.
BollingerPeriod Longitud de las bandas de Bollinger. Predeterminado: 20.
BollingerDeviation Multiplicador de desviación estándar para las bandas de Bollinger. Predeterminado: 2,0.
BaseVolume Volumen inicial de orden antes de los ajustes de martingala. Predeterminado: 0,1.
LossMultiplier Multiplicador aplicado al siguiente volumen de orden después de un ciclo perdedor. Predeterminado: 1,55.
AverageProfitTarget Beneficio no realizado medio por contrato necesario para cerrar todas las posiciones. Predeterminado: 2,8.
CandleType Tipo de vela utilizado para los cálculos (por defecto, marco temporal de 1 minuto).

Señales

Entrada larga

  1. El cierre de la vela anterior está por debajo o igual a la banda de Bollinger inferior.
  2. El cierre anterior es mayor que la SMA de 100 periodos (tendencia al alza).
  3. El valor del Force Index es positivo.

Entrada corta

  1. El cierre de la vela anterior está por encima o igual a la banda de Bollinger superior.
  2. El cierre anterior es menor que la SMA de 100 periodos (tendencia a la baja).
  3. El valor del Force Index es negativo.

Salidas

  • Cuando el beneficio no realizado medio por contrato de todas las posiciones abiertas alcanza AverageProfitTarget, todas las posiciones se cierran a mercado.
  • Después de cada posición plana, la estrategia ajusta el siguiente volumen de orden: lo multiplica por LossMultiplier tras un ciclo perdedor y lo reinicia a BaseVolume tras un ciclo rentable.

Notas

  • La adaptación de martingala usa el PnL realizado para decidir cuándo se produjo una racha de pérdidas; asegúrese de usar la estrategia solo en instrumentos donde sea aceptable aumentar el volumen.
  • Como las estrategias de StockSharp trabajan con posiciones netas, la cobertura de la versión MQL (cestas largas y cortas simultáneas) se aproxima mediante posiciones agregadas.
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;

public class JbStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private int _cooldown;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }

	public JbStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator");
		_stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk");
		_takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "Risk");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_fast = null; _slow = null;
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0; _cooldown = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, ProcessCandle);
		subscription.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; }
		if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; }

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}

		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{ if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; }
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{ if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; }

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}