Español
Ver en GitHub

Estrategia de Reversión Parabolic SAR

El indicador Parabolic SAR coloca puntos por encima o por debajo del precio para señalar la dirección de la tendencia. Cuando los puntos cambian de lado, puede marcar el final del movimiento anterior. Esta estrategia entra en operaciones en ese cambio, esperando una reversión a corto plazo.

Las pruebas indican una rentabilidad anual media de aproximadamente el 148%. Funciona mejor en el mercado de divisas.

Se mantiene un valor de Parabolic SAR en ejecución para cada vela. Si el indicador pasa de estar por encima del precio a estar por debajo, se abre una posición larga. Si pasa de estar por debajo a estar por encima, se ejecuta una operación corta. El método no utiliza un objetivo de beneficio explícito y típicamente depende de una salida discrecional o stops de seguimiento fuera del código de muestra.

Dado que el SAR reacciona rápidamente, pueden producirse señales falsas en mercados laterales, por lo que es mejor usarlo cuando el precio realiza oscilaciones decisivas.

Detalles

  • Criterios de entrada: El Parabolic SAR cambia de lado respecto al precio.
  • Largo/Corto: Ambos.
  • Criterios de salida: Stop manual o externo.
  • Stops: No definidos.
  • Valores predeterminados:
    • InitialAcceleration = 0.02
    • MaxAcceleration = 0.2
    • CandleType = 15 minute
  • Filtros:
    • Categoría: Seguimiento de tendencia
    • Dirección: Ambos
    • Indicadores: Parabolic SAR
    • Stops: Opcional
    • Complejidad: Básico
    • Marco temporal: Intradía
    • Estacionalidad: No
    • Redes neuronales: No
    • Divergencia: No
    • Nivel de riesgo: Medio
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>
/// Parabolic SAR Reversal strategy.
/// When the SAR moves from above the close to below it the position turns long, and when it moves from below to above it turns short.
/// There is no other exit.
/// </summary>
public class ParabolicSarReversalStrategy : Strategy
{
	private readonly StrategyParam<decimal> _initialAcceleration;
	private readonly StrategyParam<decimal> _maxAcceleration;
	private readonly StrategyParam<DataType> _candleType;

	private bool? _prevSarAbove;

	/// <summary>
	/// Initial acceleration factor of the SAR.
	/// </summary>
	public decimal InitialAcceleration
	{
		get => _initialAcceleration.Value;
		set => _initialAcceleration.Value = value;
	}

	/// <summary>
	/// Maximum acceleration factor of the SAR.
	/// </summary>
	public decimal MaxAcceleration
	{
		get => _maxAcceleration.Value;
		set => _maxAcceleration.Value = value;
	}

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

	/// <summary>
	/// Constructor.
	/// </summary>
	public ParabolicSarReversalStrategy()
	{
		_initialAcceleration = Param(nameof(InitialAcceleration), 0.02m)
			.SetGreaterThanZero()
			.SetDisplay("Initial Acceleration", "Initial acceleration factor of the SAR", "Indicators");

		_maxAcceleration = Param(nameof(MaxAcceleration), 0.2m)
			.SetGreaterThanZero()
			.SetDisplay("Max Acceleration", "Maximum acceleration factor of the SAR", "Indicators");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(15).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles to use", "General");
	}

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_prevSarAbove = null;
	}

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

		_prevSarAbove = null;

		var sar = new ParabolicSar
		{
			Acceleration = InitialAcceleration,
			AccelerationMax = MaxAcceleration,
		};

		var subscription = SubscribeCandles(CandleType);
		subscription
			.BindEx(sar, ProcessCandle)
			.Start();

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

	private void ProcessCandle(ICandleMessage candle, IIndicatorValue sarValue)
	{
		if (candle.State != CandleStates.Finished || !sarValue.IsFormed || sarValue.IsEmpty)
			return;

		var sar = sarValue.GetValue<decimal>();

		if (sar <= 0)
			return;

		var isSarAbove = sar > candle.ClosePrice;
		var wasSarAbove = _prevSarAbove;
		_prevSarAbove = isSarAbove;

		if (wasSarAbove is not bool previous || previous == isSarAbove || !IsFormedAndOnlineAndAllowTrading())
			return;

		if (!isSarAbove && Position <= 0)
			BuyMarket(Volume + Math.Abs(Position));
		else if (isSarAbove && Position >= 0)
			SellMarket(Volume + Math.Abs(Position));
	}
}