Deutsch DE
Auf GitHub ansehen

Stochastic-Ausbruch-Strategie

Dieser Ausbruchsansatz überwacht den Stochastic-Oszillator auf scharfe Bewegungen weg von seinem jüngsten Durchschnitt. Wenn die %K-Linie über oder unter einen volatilitätsangepassten Schwellenwert bricht, signalisiert dies einen Momentum-Schub, der einen Trend beginnen könnte.

Tests zeigen eine durchschnittliche jährliche Rendite von etwa 181%. Die Strategie funktioniert am besten im Kryptomarkt.

Eine Long-Position wird ausgelöst, wenn %K nach einer Kontraktionsphase über den oberen Schwellenwert kreuzt. Eine Short-Position wird eingegangen, wenn %K unter den unteren Schwellenwert bricht. Der Trade wird geschlossen, wenn der Oszillator zurück in Richtung seines Durchschnitts driftet oder einen Schutz-Stop trifft.

Die Strategie ist für Intraday-Trader konzipiert, die früh in Momentum-Schwünge einsteigen möchten. Volatilitätsbasierte Bänder helfen, Rauschen zu filtern, sodass nur entschiedene Bewegungen Signale erzeugen.

Details

  • Einstiegskriterien:
    • Long: %K > Avg + DeviationMultiplier * StdDev
    • Short: %K < Avg - DeviationMultiplier * StdDev
  • Long/Short: Beide Seiten.
  • Ausstiegskriterien:
    • Long: Ausstieg wenn %K < Avg
    • Short: Ausstieg wenn %K > Avg
  • Stops: Ja, prozentualer Stop-Loss.
  • Standardwerte:
    • StochasticPeriod = 14
    • KPeriod = 3
    • DPeriod = 3
    • LookbackPeriod = 20
    • DeviationMultiplier = 2.0m
    • CandleType = TimeSpan.FromMinutes(5)
  • Filter:
    • Kategorie: Ausbruch
    • Richtung: Beide
    • Indikatoren: Stochastic Oscillator
    • Stops: Ja
    • Komplexität: Mittel
    • Zeitrahmen: Intraday
    • Saisonalität: Nein
    • Neuronale Netze: Nein
    • Divergenz: Nein
    • Risikolevel: Mittel
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;
	}
}