日本語 JA
GitHub で見る

Volatility Adjusted Mean Reversion Strategy

This variation of mean reversion scales entry thresholds by the ratio of ATR to standard deviation. When volatility increases relative to typical noise, the distance needed to trigger a trade grows, helping avoid premature signals during chaotic swings.

Testing indicates an average annual return of about 115%. It performs best in the stocks market.

A long position opens when price falls below the moving average by more than the adjusted threshold. A short position opens when price rises above the average by the same measure. Positions exit once price closes back near the average level.

The adaptive threshold makes this strategy suitable for markets with changing volatility regimes. A stop-loss equal to twice the ATR limits risk while waiting for reversion.

Details

  • Entry Criteria:
    • Long: Close < MA - Multiplier * ATR / (ATR/StdDev)
    • Short: Close > MA + Multiplier * ATR / (ATR/StdDev)
  • Long/Short: Both sides.
  • Exit Criteria:
    • Long: Exit when close >= MA
    • Short: Exit when close <= MA
  • Stops: Yes, dynamic based on ATR.
  • Default Values:
    • Period = 20
    • Multiplier = 2.0m
    • CandleType = TimeSpan.FromMinutes(5)
  • Filters:
    • Category: Mean Reversion
    • Direction: Both
    • Indicators: ATR, StdDev
    • Stops: Yes
    • Complexity: Intermediate
    • Timeframe: Intraday
    • Seasonality: No
    • Neural networks: No
    • Divergence: No
    • Risk Level: Medium
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>
/// Volatility Adjusted Mean Reversion strategy.
/// Uses ATR and Standard Deviation to create adaptive entry thresholds.
/// </summary>
public class VolatilityAdjustedMeanReversionStrategy : Strategy
{
	private readonly StrategyParam<int> _periodParam;
	private readonly StrategyParam<decimal> _multiplierParam;
	private readonly StrategyParam<DataType> _candleTypeParam;

	private SimpleMovingAverage _sma;
	private AverageTrueRange _atr;
	private StandardDeviation _stdDev;
	
	/// <summary>
	/// Period for indicators.
	/// </summary>
	public int Period
	{
		get => _periodParam.Value;
		set => _periodParam.Value = value;
	}

	/// <summary>
	/// Multiplier for entry threshold.
	/// </summary>
	public decimal Multiplier
	{
		get => _multiplierParam.Value;
		set => _multiplierParam.Value = value;
	}

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

	/// <summary>
	/// Constructor.
	/// </summary>
	public VolatilityAdjustedMeanReversionStrategy()
	{
		_periodParam = Param(nameof(Period), 20)
			.SetGreaterThanZero()
			.SetDisplay("Period", "Period for indicators", "Parameters")
			
			.SetOptimize(10, 50, 10);

		_multiplierParam = Param(nameof(Multiplier), 2.0m)
			.SetRange(0.1m, decimal.MaxValue)
			.SetDisplay("Multiplier", "Multiplier for entry threshold", "Parameters")
			
			.SetOptimize(1.0m, 3.0m, 0.5m);

		_candleTypeParam = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Candle type for strategy", "Common");
	}

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

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

		_sma = null;
		_atr = null;
		_stdDev = null;
	}

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

		// Create indicators
		_sma = new SMA { Length = Period };
		_atr = new AverageTrueRange { Length = Period };
		_stdDev = new StandardDeviation { Length = Period };

		// Create subscription and bind indicators
		var subscription = SubscribeCandles(CandleType);
		
		// First, bind SMA and ATR
		subscription
			.Bind(_sma, _atr, _stdDev, ProcessCandle)
			.Start();

		// Setup chart visualization if available
		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, _sma);
			DrawIndicator(area, _atr);
			DrawOwnTrades(area);
		}
		
		// Enable position protection
		StartProtection(
			takeProfit: new Unit(0, UnitTypes.Absolute), // No take profit
			stopLoss: new Unit(2, UnitTypes.Absolute) // Stop loss at 2*ATR
		);
	}

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

		if (!IsFormedAndOnlineAndAllowTrading())
			return;
		
		// Skip if standard deviation is too small to avoid division by zero
		if (stdDevValue < 0.0001m)
			return;
			
		// Calculate volatility ratio
		var volatilityRatio = atrValue / stdDevValue;
		
		// Calculate volatility-adjusted thresholds
		var threshold = Multiplier * atrValue / volatilityRatio;
		var upperThreshold = smaValue + threshold;
		var lowerThreshold = smaValue - threshold;
		
		// Long setup - price below lower threshold
		if (candle.ClosePrice < lowerThreshold && Position <= 0)
		{
			// Buy signal - price has deviated too much below average
			BuyMarket(Volume + Math.Abs(Position));
		}
		// Short setup - price above upper threshold
		else if (candle.ClosePrice > upperThreshold && Position >= 0)
		{
			// Sell signal - price has deviated too much above average
			SellMarket(Volume + Math.Abs(Position));
		}
		// Exit long position when price returns to average
		else if (Position > 0 && candle.ClosePrice >= smaValue)
		{
			// Close long position
			SellMarket(Position);
		}
		// Exit short position when price returns to average
		else if (Position < 0 && candle.ClosePrice <= smaValue)
		{
			// Close short position
			BuyMarket(Math.Abs(Position));
		}
	}
}