Deutsch DE
Auf GitHub ansehen

Puria Method-Strategie

Übersicht

Die Puria Method-Strategie ist ein Trendfolge-System, das ursprünglich für MetaTrader entwickelt wurde. Es kombiniert drei gleitende Durchschnitte mit einem MACD-Trendfilter, um Momentum-Ausbrüche zu erkennen. Die StockSharp-Konvertierung behält die ursprüngliche Einstiegslogik bei und fügt moderne Risikokontrollen hinzu, wie partielle Gewinnmitnahmen und automatisierte Trailing-Stops.

Handelslogik

  • Berechnung von drei gleitenden Durchschnitten mit konfigurierbaren Glättungsmethoden und Preisquellen.
  • Auswertung der Differenz zwischen dem langsameren Basis-MA und den beiden schnelleren MAs der vorherigen Kerze. Ein bullisches Signal erfordert, dass beide schnellen MAs mindestens 0,5 Punkte über der Basis liegen; ein bearisches Signal erfordert, dass die Basis um denselben Abstand führt.
  • Bestätigung der Marktrichtung mit der MACD-Hauptlinie. Long-Trades erfordern, dass der vorherige MACD-Wert positiv ist und der jüngste MACD-Verlauf für die konfigurierte Anzahl von Kerzen nicht-fallend ist. Short-Trades erfordern die entgegengesetzten Bedingungen.
  • Wenn ein Einstieg ausgelöst wird, schließt die Strategie eine entgegengesetzte Position (falls vorhanden) und öffnet eine neue Nettoposition in Signalrichtung.

Risikomanagement

  • Stop Loss / Take Profit: Preise werden vom Einstieg aus mit Pip-Abständen berechnet und auf den Kursschritt des Instruments normiert.
  • Trailing Stop: Sobald die Position über den Trailing-Schwellenwert plus Schritt hinausgeht, wird der Stop bei jedem weiteren Trailing-Schritt nachgezogen.
  • Teilausstieg: Nachdem der Preis einen minimalen Gewinnabstand zurückgelegt hat, wird ein konfigurierbarer Anteil der Position geschlossen, um Gewinne zu sichern.
  • Positionsverwaltung: Der Algorithmus verfolgt den höchsten (Long) oder niedrigsten (Short) Preis nach dem Einstieg, um Stop- oder Gewinnregeln auszulösen, wenn Kerzen diese Niveaus durchbrechen.

Parameter

Name Beschreibung
StopLossPips Stop-Loss-Abstand in Pips.
TakeProfitPips Take-Profit-Abstand in Pips.
TrailingStopPips Trailing-Stop-Abstand in Pips.
TrailingStepPips Minimaler Gewinnvorschub, bevor der Trailing-Stop aktualisiert wird.
MinProfitStepPips Minimaler Abstand in Pips vor der Teilgewinnmitnahme.
MinProfitFraction Anteil der Position, der bei Erreichen des Mindestgewinnschritts geschlossen wird.
CandleType Primäre Kerzenserie, die von der Strategie verwendet wird.
Ma0Period, Ma1Period, Ma2Period Perioden für die drei gleitenden Durchschnitte.
Ma0Shift, Ma1Shift, Ma2Shift Optionale Kerzenverschiebungen für jeden gleitenden Durchschnitt.
Ma0Method, Ma1Method, Ma2Method Glättungsmethoden für gleitende Durchschnitte (einfach, exponentiell, geglättet, linear gewichtet).
Ma0Price, Ma1Price, Ma2Price Kerzenpreisquellen für die gleitenden Durchschnitte.
MacdFastPeriod, MacdSlowPeriod, MacdSignalPeriod MACD-Konfiguration.
MacdTrendBars Anzahl der Kerzen zur Verifikation des monotonen MACD-Trends (mindestens 3).
MacdPrice Kerzenpreisquelle für die MACD-Berechnung.

Hinweise

  • Die Strategie verwendet die vorherige abgeschlossene Kerze für MA- und MACD-Vergleiche, um Abhängigkeit von unvollständigen Kerzendaten zu vermeiden.
  • Die Pip-Größe wird automatisch aus dem Kursschritt des Instruments und der Dezimalgenauigkeit abgeleitet.
  • Trailing- und Teilausstiegsfunktionen erfordern Konfigurationswerte ungleich null; andernfalls bleiben die entsprechenden Blöcke inaktiv.
  • Die konvertierte Version basiert ausschließlich auf abgeschlossenen Kerzen (CandleStates.Finished) und sollte mit einer Kerzenserie verwendet werden, die dem ursprünglichen Chartzeitrahmen entspricht.
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;

public class PuriaMethodStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private int _cooldown;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }

	public PuriaMethodStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator");
		_stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk");
		_takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "Risk");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_fast = null; _slow = null;
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0; _cooldown = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, ProcessCandle);
		subscription.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; }
		if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; }

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}

		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{ if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; }
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{ if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; }

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}