Español ES
Ver en GitHub

Estrategia Slime Mold RSI

Una conversión directa del asesor experto MQL4 "Slime_Mold_RSI_v1.1". La estrategia construye un único perceptrón combinando cuatro lecturas de RSI (12, 36, 108 y 324) calculadas sobre el precio mediano. Cada valor de RSI se normaliza del rango original 0–100 a -1…+1 y se multiplica por un peso configurable. Un cruce por cero de la suma ponderada invierte la posición.

Cómo Funciona

  • Calcular el precio mediano de cada vela finalizada y alimentarlo en cuatro indicadores de Índice de Fuerza Relativa con longitudes de 12, 36, 108 y 324.
  • Normalizar cada valor de RSI al intervalo -1…+1 y aplicar el peso correspondiente. Los valores predeterminados (-100) reproducen los coeficientes originales del perceptrón (x - 100).
  • Sumar las cuatro entradas ponderadas para producir la salida del perceptrón de la vela actual.
  • Comparar el valor más reciente con la salida del perceptrón de la vela anterior para detectar cruces por cero y generar señales de trading.

Reglas de Trading

  • Entrada larga: El valor anterior del perceptrón es inferior a cero y el valor actual sube por encima de cero. La estrategia cierra cualquier exposición corta y establece una posición larga de tamaño Volume.
  • Entrada corta: El valor anterior del perceptrón es superior a cero y el valor actual cae por debajo de cero. La estrategia sale de cualquier posición larga y abre una posición corta de tamaño Volume.
  • Gestión de posiciones: No hay objetivos de beneficio explícitos ni órdenes de stop-loss. Las posiciones solo se cambian cuando ocurre un nuevo cruce por cero.

Parámetros

  • Weight1 – coeficiente aplicado a la entrada de RSI normalizada de 12 períodos.
  • Weight2 – coeficiente aplicado a la entrada de RSI normalizada de 36 períodos.
  • Weight3 – coeficiente aplicado a la entrada de RSI normalizada de 108 períodos.
  • Weight4 – coeficiente aplicado a la entrada de RSI normalizada de 324 períodos.
  • CandleType – marco temporal de las velas suministradas a la estrategia. El valor predeterminado es velas de 1 hora.

Detalles

  • Criterios de entrada: Cruce por cero del perceptrón RSI ponderado.
  • Largo/Corto: Ambos (siempre en el mercado después de la primera señal).
  • Criterios de salida: El cruce opuesto por cero invierte la posición.
  • Stops: Ninguno.
  • Valores predeterminados:
    • Weight1 = -100
    • Weight2 = -100
    • Weight3 = -100
    • Weight4 = -100
    • CandleType = velas de 1 hora
  • Filtros:
    • Categoría: Perceptrón / Oscilador
    • Dirección: Bidireccional
    • Indicadores: RSI (precio mediano)
    • Stops: No
    • Complejidad: Intermedio (requiere cuatro indicadores de largo horizonte)
    • Marco temporal: Configurable (predeterminado intradía por hora)
    • Estacionalidad: No
    • Redes neuronales: Perceptrón lineal
    • Divergencia: No
    • Nivel de riesgo: Depende del volumen y pesos elegidos

Notas

  • La implementación mantiene el registro de la salida previa del perceptrón incluso cuando el trading está deshabilitado para garantizar la continuidad del estado una vez que el trading se reanuda.
  • El precio mediano se utiliza para coincidir con la configuración PRICE_MEDIAN del script original de MetaTrader.
  • La estrategia invierte las posiciones instantáneamente, así que tenga en cuenta el deslizamiento potencial al elegir pesos y volumen.
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>
/// Slime Mold RSI perceptron strategy converted from MQL4.
/// The strategy sums weighted RSI inputs to generate zero-crossing signals.
/// </summary>
public class SlimeMoldRsiStrategy : Strategy
{
	private readonly StrategyParam<decimal> _weight1;
	private readonly StrategyParam<decimal> _weight2;
	private readonly StrategyParam<decimal> _weight3;
	private readonly StrategyParam<decimal> _weight4;
	private readonly StrategyParam<DataType> _candleType;

	private RelativeStrengthIndex _rsi12 = null!;
	private RelativeStrengthIndex _rsi36 = null!;
	private RelativeStrengthIndex _rsi108 = null!;
	private RelativeStrengthIndex _rsi324 = null!;

	private decimal? _previousPerceptron;

	/// <summary>
	/// Weight applied to the 12-period RSI input.
	/// </summary>
	public decimal Weight1
	{
		get => _weight1.Value;
		set => _weight1.Value = value;
	}

	/// <summary>
	/// Weight applied to the 36-period RSI input.
	/// </summary>
	public decimal Weight2
	{
		get => _weight2.Value;
		set => _weight2.Value = value;
	}

	/// <summary>
	/// Weight applied to the 108-period RSI input.
	/// </summary>
	public decimal Weight3
	{
		get => _weight3.Value;
		set => _weight3.Value = value;
	}

	/// <summary>
	/// Weight applied to the 324-period RSI input.
	/// </summary>
	public decimal Weight4
	{
		get => _weight4.Value;
		set => _weight4.Value = value;
	}

	/// <summary>
	/// Candle type used for RSI calculations.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of the <see cref="SlimeMoldRsiStrategy"/> class.
	/// </summary>
	public SlimeMoldRsiStrategy()
	{
		_weight1 = Param(nameof(Weight1), -100m)
			.SetDisplay("Weight 1", "Weight applied to the 12-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_weight2 = Param(nameof(Weight2), -100m)
			.SetDisplay("Weight 2", "Weight applied to the 36-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_weight3 = Param(nameof(Weight3), -100m)
			.SetDisplay("Weight 3", "Weight applied to the 108-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_weight4 = Param(nameof(Weight4), -100m)
			.SetDisplay("Weight 4", "Weight applied to the 324-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe for candles used in calculations", "General");
	}

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

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

		// Drop cached indicator instances and perceptron history.
		_rsi12 = null!;
		_rsi36 = null!;
		_rsi108 = null!;
		_rsi324 = null!;
		_previousPerceptron = null;
	}

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

		// Create RSI indicators for each horizon used by the original perceptron.
		_rsi12 = new RelativeStrengthIndex { Length = 12 };
		_rsi36 = new RelativeStrengthIndex { Length = 36 };
		_rsi108 = new RelativeStrengthIndex { Length = 108 };
		_rsi324 = new RelativeStrengthIndex { Length = 324 };

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

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

		if (_rsi12 is null || _rsi36 is null || _rsi108 is null || _rsi324 is null)
			return;

		// Median price replicates PRICE_MEDIAN used in the original script.
		var medianPrice = (candle.HighPrice + candle.LowPrice) / 2m;

		var input = new DecimalIndicatorValue(_rsi12, medianPrice, candle.ServerTime) { IsFinal = true };
		_rsi12.Process(input);
		_rsi36.Process(new DecimalIndicatorValue(_rsi36, medianPrice, candle.ServerTime) { IsFinal = true });
		_rsi108.Process(new DecimalIndicatorValue(_rsi108, medianPrice, candle.ServerTime) { IsFinal = true });
		_rsi324.Process(new DecimalIndicatorValue(_rsi324, medianPrice, candle.ServerTime) { IsFinal = true });

		// Wait until every RSI is fully formed before evaluating signals.
		if (!_rsi12.IsFormed || !_rsi36.IsFormed || !_rsi108.IsFormed || !_rsi324.IsFormed)
			return;

		var rsi12Value = _rsi12.GetCurrentValue();
		var rsi36Value = _rsi36.GetCurrentValue();
		var rsi108Value = _rsi108.GetCurrentValue();
		var rsi324Value = _rsi324.GetCurrentValue();

		var currentPerceptron =
			(Weight1 * NormalizeRsi(rsi12Value)) +
			(Weight2 * NormalizeRsi(rsi36Value)) +
			(Weight3 * NormalizeRsi(rsi108Value)) +
			(Weight4 * NormalizeRsi(rsi324Value));

		// Initialize the history with the first complete value.
		if (_previousPerceptron is null)
		{
			_previousPerceptron = currentPerceptron;
			return;
		}

		var previousPerceptron = _previousPerceptron.Value;

		// Even if trading is disabled, keep the state in sync with the incoming data.
		// indicators already checked above via IsFormed

		// Zero-crossing from negative to positive triggers a long entry.
		if (previousPerceptron < 0m && currentPerceptron > 0m && Position <= 0m)
		{
				BuyMarket();
				LogInfo($"Long entry. Previous perceptron: {previousPerceptron:F2}, current: {currentPerceptron:F2}");
		}
		// Zero-crossing from positive to negative triggers a short entry.
		else if (previousPerceptron > 0m && currentPerceptron < 0m && Position >= 0m)
		{
				SellMarket();
				LogInfo($"Short entry. Previous perceptron: {previousPerceptron:F2}, current: {currentPerceptron:F2}");
		}

		// Store the latest perceptron value for the next signal evaluation.
		_previousPerceptron = currentPerceptron;
	}

	private static decimal NormalizeRsi(decimal rsiValue)
	{
		// Transform RSI from [0,100] into [-1,+1] as in the original script.
		return ((rsiValue / 100m) - 0.5m) * 2m;
	}
}