Español ES
Ver en GitHub

Estrategia Volume Spike Trend

Volume Spike Trend monitorea súbitos aumentos en el volumen negociado. Cuando el volumen actual supera el promedio reciente por un multiplicador determinado, señala una fuerte participación.

Las pruebas indican un retorno anual promedio de aproximadamente 175%. Funciona mejor en el mercado de acciones.

Si el volumen presenta un spike y el precio está por encima de la media móvil, la estrategia compra; si el volumen presenta un spike por debajo del promedio, vende en corto. Las operaciones salen cuando el volumen vuelve a caer por debajo del promedio o se alcanza el stop-loss.

Este método busca capturar movimientos impulsados por una explosión de actividad.

Detalles

  • Criterios de entrada: El cambio de volumen supera VolumeSpikeMultiplier veces el promedio.
  • Largo/Corto: Ambas direcciones.
  • Criterios de salida: El volumen cae por debajo del promedio o stop.
  • Stops: Sí.
  • Valores predeterminados:
    • MAPeriod = 20
    • VolAvgPeriod = 20
    • VolumeSpikeMultiplier = 2.0m
    • CandleType = TimeSpan.FromMinutes(5)
  • Filtros:
    • Categoría: Ruptura
    • Dirección: Ambos
    • Indicadores: Volumen, MA
    • Stops: Sí
    • 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>
/// Volume Spike strategy.
/// Enters when volume spikes above average and price is above/below MA.
/// </summary>
public class VolumeSpikeStrategy : Strategy
{
	private readonly StrategyParam<int> _maPeriod;
	private readonly StrategyParam<decimal> _volumeSpikeMultiplier;
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _cooldownBars;

	private decimal _previousVolume;
	private int _cooldown;

	/// <summary>
	/// MA Period.
	/// </summary>
	public int MAPeriod
	{
		get => _maPeriod.Value;
		set => _maPeriod.Value = value;
	}

	/// <summary>
	/// Volume Spike Multiplier.
	/// </summary>
	public decimal VolumeSpikeMultiplier
	{
		get => _volumeSpikeMultiplier.Value;
		set => _volumeSpikeMultiplier.Value = value;
	}

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

	/// <summary>
	/// Cooldown bars between trades.
	/// </summary>
	public int CooldownBars
	{
		get => _cooldownBars.Value;
		set => _cooldownBars.Value = value;
	}

	/// <summary>
	/// Initialize the Volume Spike strategy.
	/// </summary>
	public VolumeSpikeStrategy()
	{
		_maPeriod = Param(nameof(MAPeriod), 20)
			.SetDisplay("MA Period", "Period for Moving Average calculation", "Indicators")
			.SetOptimize(10, 50, 10);

		_volumeSpikeMultiplier = Param(nameof(VolumeSpikeMultiplier), 2.0m)
			.SetDisplay("Volume Spike Multiplier", "Minimum volume increase for signal", "Entry")
			.SetOptimize(1.5m, 3.0m, 0.5m);

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

		_cooldownBars = Param(nameof(CooldownBars), 500)
			.SetRange(1, 1000)
			.SetDisplay("Cooldown Bars", "Bars to wait between trades", "General");
	}

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_previousVolume = default;
		_cooldown = default;
	}

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

		_previousVolume = 0;
		_cooldown = 0;

		var ma = new SimpleMovingAverage { Length = MAPeriod };

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

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

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

		if (!IsFormedAndOnlineAndAllowTrading())
			return;

		if (_previousVolume == 0)
		{
			_previousVolume = candle.TotalVolume;
			return;
		}

		if (_cooldown > 0)
		{
			_cooldown--;
			_previousVolume = candle.TotalVolume;
			return;
		}

		var volumeChange = _previousVolume > 0 ? candle.TotalVolume / _previousVolume : 0;

		if (Position == 0 && volumeChange >= VolumeSpikeMultiplier)
		{
			if (candle.ClosePrice > maValue)
			{
				BuyMarket();
				_cooldown = CooldownBars;
			}
			else if (candle.ClosePrice < maValue)
			{
				SellMarket();
				_cooldown = CooldownBars;
			}
		}
		else if (Position > 0 && candle.TotalVolume < _previousVolume)
		{
			SellMarket();
			_cooldown = CooldownBars;
		}
		else if (Position < 0 && candle.TotalVolume < _previousVolume)
		{
			BuyMarket();
			_cooldown = CooldownBars;
		}

		_previousVolume = candle.TotalVolume;
	}
}