Español ES
Ver en GitHub

Stochastic Breakout Strategy

This breakout approach monitors the Stochastic oscillator for sharp moves away from its recent average. When the %K line breaks above or below a volatility-adjusted threshold, it signals a burst of momentum that may start a trend.

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

A long position is triggered when %K crosses above the upper threshold after a period of contraction. A short position is taken when %K breaks below the lower threshold. The trade is closed when the oscillator drifts back toward its average or hits a protective stop.

The strategy is designed for intraday traders who want early entry into momentum swings. Using volatility-based bands helps filter noise so only decisive moves create signals.

Details

  • Entry Criteria:
    • Long: %K > Avg + DeviationMultiplier * StdDev
    • Short: %K < Avg - DeviationMultiplier * StdDev
  • Long/Short: Both sides.
  • Exit Criteria:
    • Long: Exit when %K < Avg
    • Short: Exit when %K > Avg
  • Stops: Yes, percent stop-loss.
  • Default Values:
    • StochasticPeriod = 14
    • KPeriod = 3
    • DPeriod = 3
    • LookbackPeriod = 20
    • DeviationMultiplier = 2.0m
    • CandleType = TimeSpan.FromMinutes(5)
  • Filters:
    • Category: Breakout
    • Direction: Both
    • Indicators: Stochastic Oscillator
    • 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>
/// Stochastic Breakout Strategy.
/// This strategy identifies breakouts based on the Stochastic oscillator values compared to their historical average.
/// </summary>
public class StochasticBreakoutStrategy : Strategy
{
	private readonly StrategyParam<int> _stochasticPeriod;
	private readonly StrategyParam<int> _kPeriod;
	private readonly StrategyParam<int> _dPeriod;
	private readonly StrategyParam<int> _lookbackPeriod;
	private readonly StrategyParam<decimal> _deviationMultiplier;
	private readonly StrategyParam<DataType> _candleType;
	
	private StochasticOscillator _stochastic;
	private SimpleMovingAverage _stochAverage;
	private StandardDeviation _stochStdDev;
	
	private decimal _prevStochValue;
	private decimal _prevStochAverage;
	private decimal _prevStochStdDev;

	/// <summary>
	/// Stochastic oscillator period.
	/// </summary>
	public int StochasticPeriod
	{
		get => _stochasticPeriod.Value;
		set => _stochasticPeriod.Value = value;
	}

	/// <summary>
	/// Stochastic %K smoothing period.
	/// </summary>
	public int KPeriod
	{
		get => _kPeriod.Value;
		set => _kPeriod.Value = value;
	}

	/// <summary>
	/// Stochastic %D smoothing period.
	/// </summary>
	public int DPeriod
	{
		get => _dPeriod.Value;
		set => _dPeriod.Value = value;
	}

	/// <summary>
	/// Lookback period for calculating the average and standard deviation.
	/// </summary>
	public int LookbackPeriod
	{
		get => _lookbackPeriod.Value;
		set => _lookbackPeriod.Value = value;
	}

	/// <summary>
	/// Deviation multiplier for breakout detection.
	/// </summary>
	public decimal DeviationMultiplier
	{
		get => _deviationMultiplier.Value;
		set => _deviationMultiplier.Value = value;
	}

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

	/// <summary>
	/// Constructor.
	/// </summary>
	public StochasticBreakoutStrategy()
	{
		_stochasticPeriod = Param(nameof(StochasticPeriod), 14)
			.SetDisplay("Stochastic Period", "Stochastic oscillator period", "Stochastic")
			
			.SetOptimize(5, 30, 5);

		_kPeriod = Param(nameof(KPeriod), 3)
			.SetDisplay("K Period", "Stochastic %K smoothing period", "Stochastic")
			
			.SetOptimize(1, 5, 1);

		_dPeriod = Param(nameof(DPeriod), 3)
			.SetDisplay("D Period", "Stochastic %D smoothing period", "Stochastic")
			
			.SetOptimize(1, 5, 1);

		_lookbackPeriod = Param(nameof(LookbackPeriod), 20)
			.SetDisplay("Lookback Period", "Lookback period for calculating the average and standard deviation", "Breakout")
			
			.SetOptimize(10, 50, 5);

		_deviationMultiplier = Param(nameof(DeviationMultiplier), 2.0m)
			.SetDisplay("Deviation Multiplier", "Deviation multiplier for breakout detection", "Breakout")
			
			.SetOptimize(1.0m, 3.0m, 0.5m);

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

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

		_prevStochValue = 0;
		_prevStochAverage = 0;
		_prevStochStdDev = 0;
	}


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

		// Initialize indicators
		_stochastic = new StochasticOscillator
		{
			K = { Length = StochasticPeriod },
			D = { Length = DPeriod },
		};

		_stochAverage = new SMA { Length = LookbackPeriod };
		_stochStdDev = new StandardDeviation { Length = LookbackPeriod };
		
		Indicators.Add(_stochastic);

		// Create subscription and bind indicators
		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ProcessCandle)
			.Start();

		// Setup chart visualization if available
		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, _stochastic);
			DrawOwnTrades(area);
		}
		
		// Start position protection
		StartProtection(
			takeProfit: new Unit(2, UnitTypes.Percent),
			stopLoss: new Unit(2, UnitTypes.Percent)
		);
	}

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

		var stochResult = _stochastic.Process(candle);
		if (!_stochastic.IsFormed)
			return;

		var stochTyped = (StochasticOscillatorValue)stochResult;
		if (stochTyped.K is not decimal stochK)
			return;

		// Calculate average and standard deviation of stochastic
		var stochAvgValue = _stochAverage.Process(new DecimalIndicatorValue(_stochAverage, stochK, candle.ServerTime) { IsFinal = true }).ToDecimal();
		var tempStdDevValue = _stochStdDev.Process(new DecimalIndicatorValue(_stochStdDev, stochK, candle.ServerTime) { IsFinal = true }).ToDecimal();

		if (!_stochAverage.IsFormed || !_stochStdDev.IsFormed)
		{
			_prevStochValue = stochK;
			_prevStochAverage = stochAvgValue;
			_prevStochStdDev = tempStdDevValue;
			return;
		}

		// First values initialization - skip trading decision
		if (_prevStochValue == 0)
		{
			_prevStochValue = stochK;
			_prevStochAverage = stochAvgValue;
			_prevStochStdDev = tempStdDevValue;
			return;
		}

		// Calculate breakout thresholds
		var upperThreshold = _prevStochAverage + _prevStochStdDev * DeviationMultiplier;
		var lowerThreshold = _prevStochAverage - _prevStochStdDev * DeviationMultiplier;

		// Buy when stochastic breaks above upper threshold
		if (stochK > upperThreshold && _prevStochValue <= upperThreshold && Position == 0)
		{
			BuyMarket();
		}
		// Sell when stochastic breaks below lower threshold
		else if (stochK < lowerThreshold && _prevStochValue >= lowerThreshold && Position == 0)
		{
			SellMarket();
		}

		// Store current values for next comparison
		_prevStochValue = stochK;
		_prevStochAverage = stochAvgValue;
		_prevStochStdDev = tempStdDevValue;
	}
}