Русский RU
Открыть на GitHub

Стратегия прорыва по Стохастику

Этот подход отслеживает осциллятор Стохастик на предмет резких движений от его недавнего среднего. Когда линия %K пробивает волатильно‑скорректированный порог вверх или вниз, это сигнализирует о всплеске импульса, который может запустить тренд.

Тестирование показывает среднегодичную доходность около 181%. Стратегию лучше запускать на крипторынке.

Длинная позиция открывается, когда %K пересекает верхний порог после периода сжатия. Шорт берется, когда %K пробивает нижний порог. Сделка закрывается, когда осциллятор возвращается к своему среднему или срабатывает защитный стоп.

Стратегия рассчитана на внутридневных трейдеров, желающих рано войти в импульсное движение. Использование волатильностных полос помогает отфильтровывать шум, чтобы сигналы возникали только при решительных движениях.

Подробности

  • Условия входа:
    • Лонг: %K > Avg + DeviationMultiplier * StdDev
    • Шорт: %K < Avg - DeviationMultiplier * StdDev
  • Длинные/короткие: обе стороны.
  • Условия выхода:
    • Лонг: выход при %K < Avg
    • Шорт: выход при %K > Avg
  • Стопы: да, процентный стоп‑лосс.
  • Значения по умолчанию:
    • StochasticPeriod = 14
    • KPeriod = 3
    • DPeriod = 3
    • LookbackPeriod = 20
    • DeviationMultiplier = 2.0m
    • CandleType = TimeSpan.FromMinutes(5)
  • Фильтры:
    • Категория: Breakout
    • Направление: оба
    • Индикаторы: Stochastic Oscillator
    • Стопы: да
    • Сложность: средняя
    • Таймфрейм: внутридневной
    • Сезонность: нет
    • Нейросети: нет
    • Дивергенция: нет
    • Уровень риска: средний
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;
	}
}