Deutsch DE
Auf GitHub ansehen

Stochastic Überkauft/Überverkauft-Umkehr

Die Strategie reagiert auf extreme Niveaus des Stochastic Oszillators. Wenn die %K-Linie in überverkauftes Terrain abtaucht, erwartet das System eine Erholung, während überkaufte Werte einen Rückgang ankündigen können. Die Methode läuft auf kurzen Intraday-Kerzen, sodass Signale schnell eintreffen.

Tests zeigen eine durchschnittliche jährliche Rendite von etwa 73%. Sie funktioniert am besten auf dem Kryptomarkt.

Nach der Anmeldung auf dem ausgewählten Zeitrahmen überwacht sie die %K- und %D-Linien. Ein bullisches Setup entsteht, wenn %K unter 20 fällt und dann beginnt, sich zu erholen. Umgekehrt erscheint ein bärisches Setup, wenn %K über 80 steigt und anfängt, sich nach unten zu drehen. Ein fester prozentualer Stop kontrolliert das Risiko für beide Seiten.

Positionen werden geschlossen, wenn die %K-Linie wieder durch das Niveau 50 kreuzt, was signalisiert, dass sich der Schwung in die entgegengesetzte Richtung verschoben hat. Da die Stops mit dem aktuellen ATR skalieren, passt sich die Handelsgröße an die Volatilität an.

Details

  • Einstiegskriterien:
    • Long: %K < 20 mit bullischer Wende.
    • Short: %K > 80 mit bärischer Wende.
  • Long/Short: Beide.
  • Ausstiegskriterien: %K kreuzt Niveau 50 oder Stop-Loss.
  • Stops: Ja, bei 2% Abstand.
  • Standardwerte:
    • StochPeriod = 14
    • KPeriod = 3
    • DPeriod = 3
    • CandleType = 5 minute
  • Filter:
    • Kategorie: Oszillator
    • Richtung: Beide
    • Indikatoren: Stochastic
    • Stops: Ja
    • Komplexität: Grundlegend
    • Zeitrahmen: Intraday
    • Saisonalität: Nein
    • Neuronale Netze: Nein
    • Divergenz: Nein
    • Risikolevel: Mittel
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>
/// Stochastic Overbought/Oversold strategy.
/// Buys when K is oversold, sells when K is overbought.
/// </summary>
public class StochasticOverboughtOversoldStrategy : Strategy
{
	private readonly StrategyParam<int> _kPeriod;
	private readonly StrategyParam<int> _dPeriod;
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _cooldownBars;

	private int _cooldown;

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

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

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

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

	/// <summary>
	/// Constructor.
	/// </summary>
	public StochasticOverboughtOversoldStrategy()
	{
		_kPeriod = Param(nameof(KPeriod), 3)
			.SetGreaterThanZero()
			.SetDisplay("K Period", "Smoothing period for %K", "Indicators");

		_dPeriod = Param(nameof(DPeriod), 3)
			.SetGreaterThanZero()
			.SetDisplay("D Period", "Smoothing period for %D", "Indicators");

		_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();
		_cooldown = default;
	}

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

		_cooldown = 0;

		var stochastic = new StochasticOscillator
		{
			K = { Length = KPeriod },
			D = { Length = DPeriod },
		};

		var subscription = SubscribeCandles(CandleType);
		subscription
			.BindEx(stochastic, ProcessCandle)
			.Start();

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

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

		if (!stochValue.IsFormed)
			return;

		var stochTyped = (StochasticOscillatorValue)stochValue;

		if (stochTyped.K is not decimal kValue)
			return;

		if (_cooldown > 0)
		{
			_cooldown--;
			return;
		}

		if (Position == 0 && kValue < 20)
		{
			BuyMarket();
			_cooldown = CooldownBars;
		}
		else if (Position == 0 && kValue > 80)
		{
			SellMarket();
			_cooldown = CooldownBars;
		}
		else if (Position > 0 && kValue > 80)
		{
			SellMarket();
			_cooldown = CooldownBars;
		}
		else if (Position < 0 && kValue < 20)
		{
			BuyMarket();
			_cooldown = CooldownBars;
		}
	}
}