Zweiseitige Momentum Stop-Profit- und Stop-Loss-Strategie
ChaoZhang
Überblick
Die Strategie ist eine Erweiterung der auf den in TradingView integrierten, kontinuierlichen Auf-/Abwärts-Strategie. Sie verfügt über eine flexible Strategie-Richtungssetzung, mit der Rückwärtsgeschäfte getätigt werden können. Gleichzeitig sind mehrere Stop-Methoden wie Swinging Highs/Lows, ATR-Stops und Tracking-Stops sowie die entsprechenden Stop-Sets integriert. Dies ermöglicht eine bessere Risikomanagement der Strategie, die auf den ursprünglichen Handelssignalen basiert.
Strategieprinzip
Die Strategie erzeugt Käufe und Verkäufe, indem sie die Anzahl der aufeinanderfolgenden Auf- und Absteiger der K-Linien beurteilt. Der Benutzer kann die Anzahl der aufeinanderfolgenden Auf- und Absteiger der K-Linien einstellen, die für die Erzeugung des Kauf- und Verkaufssignals erforderlich sind.
Die Strategie enthält auch die Einstellung, ob der Handel umgekehrt wird. Wenn der Umkehrhandel eingeleitet wird, wird das ursprüngliche Kaufsignal zu einem Verkaufsignal und das Verkaufsignal zu einem Kaufsignal umgewandelt, wodurch der Umkehrhandel abgeschlossen wird.
Bei Ein- und Ausstieg unterstützt die Strategie eine direkte Rückzugsplatzierung, um zu verhindern, dass keine Positionen gehandelt werden können.
In Bezug auf Stop-Loss und Stop-Stopp bietet die Strategie drei Optionsmöglichkeiten zum Stop, um die Höhe/Tieflage, den ATR und die Strategie zu bewegen. Die Stop-Methode kombiniert die Positionsrichtung, die automatische Auswahl des niedrigsten Tals oder der höchsten Spitze als Radikalstop oder die Festlegung des Stop-Preises basierend auf der ATR-Dynamik.
Die Strategie kann die Stop-Loss-Spanne bei Verlusten vergrößern und die Stop-Loss-Spanne bei Gewinnen verkleinern, um eine automatische Verfolgung zu ermöglichen.
Analyse der Stärken
Der größte Vorteil dieser Strategie liegt in der Flexibilität, die sich an unterschiedliche Marktbedingungen anpasst.
- Einstellbare Kauf- und Verkaufs-Selektionsparameter für Trend- und Schwankungsbedingungen
- Umkehrhandel unterstützt, je nach Bedarf ausgerichtet
- Einrichtung von direkten Rückwärtsöffnungen, um die freie Position zu verringern
- Integration von mehreren Stop-Loss-Methoden, je nach Bedarf
- Tracking Stop-Loss und automatische Stop-Loss aktiviert
Risikoanalyse
Die Hauptrisiken dieser Strategie bestehen darin, dass zu viele K-Linien in Folge zu verpassten Handelsmöglichkeiten führen können und dass zu radikale Stop-Loss-Einstellungen zu einer Verlustvergrößerung führen können. Die Risiken werden wie folgt empfohlen:
- Anpassung der Parameter für die Anzahl der K-Linien nach oben / unten, nicht zu radikal
- Verschiedene Verlustminderungsmethoden testen und die am besten geeigneten auswählen
- Verfolgen Sie die Stop-Loss-Systeme sorgfältig und vermeiden Sie übermäßige Verluste.
Optimierungsrichtung
Die Strategie kann noch weiter optimiert werden:
- Anzahl der Auf/Ab-K-Linien, die dynamisch anhand von Indikatoren wie ATR oder Volatilität angepasst werden können
- Die Parameter für die Stop-Loss-Stopp-Ratio können für verschiedene Positionszeiten getestet werden
- Sie können den Open-Filter einstellen, um falsche Durchbrüche zu vermeiden.
- Es können weitere Hilfsindikatoren hinzugefügt werden, um die Signalqualität zu verbessern.
Zusammenfassen
Diese Strategie ist eine nützliche Erweiterung der Benchmark-Strategie, die es ermöglicht, Risiken besser zu kontrollieren und eine flexiblere Handelsweise zu erhalten. Es ist eine effektive Momentum-Strategie, die leicht optimiert und installiert werden kann.
/*backtest
start: 2023-01-07 00:00:00
end: 2023-08-30 05:20:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// Extension of the built-in strategy by Tradingview. The strategy buys after an X amount of
// consecutive bullish bars and viceversa for selling. This logic can be reversed and a Stop Loss
// with Take Profit can be added. There's also an option to adapt the SL into a Trailing Stop.
//@version=4
strategy("Consecutive Up/Down Strategy with Reverse",
overlay=true,
default_qty_type=strategy.percent_of_equity,
default_qty_value=100,
initial_capital=10000,
commission_value=0.04,
calc_on_every_tick=false,
slippage=0)
direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))
/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")
consecutiveBarsUp = input(3)
consecutiveBarsDown = input(4)
/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")
// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=2, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(5, step=.1, title="ATR Multiple")
i_TPRRR = input(5, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(true, title="Trailing Stop")
// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1]
or strategy.position_size < strategy.position_size[1]
// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na
entry_HH_price = strategy.position_size < 0 ? HH_price : na
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR
// ATR Stop
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR
// Strategy Stop
float LongStop = na
float ShortStop = na
float StratTP = na
float StratSTP = na
/////////////////////// STRATEGY LOGIC /////////////////////////////////////////
price = close
ups = 0.0
ups := price > price[1] ? nz(ups[1]) + 1 : 0
dns = 0.0
dns := price < price[1] ? nz(dns[1]) + 1 : 0
BUY=ups >= consecutiveBarsUp and bar_index > 40
SELL=dns >= consecutiveBarsDown and bar_index > 40
//Trading Inputs
DPR=input(true, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")
// Entries
if reverse
if not DPR
strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=SELL)
strategy.entry("short", strategy.short, when=BUY)
else
if not DPR
strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=BUY)
strategy.entry("short", strategy.short, when=SELL)
SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP
//TrailingStop
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
-strategy.position_avg_price
trailOffset = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
tstop := high- trailOffset - dif
if tstop<tstop[1]
tstop:=tstop[1]
else
tstop := na
StrailOffset = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0
and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
Ststop := low+ StrailOffset + Sdif
if Ststop>Ststop[1]
Ststop:=Ststop[1]
else
Ststop := na
strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL, when=i_SL)
/////////////////////// PLOTS //////////////////////////////////////////////////
plot(i_SL and strategy.position_size > 0 and not TS ? SL : i_SL and strategy.position_size > 0 and TS ? tstop : na , title='SL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size < 0 and not TS ? SSL : i_SL and strategy.position_size < 0 and TS ? Ststop : na , title='SSL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(i_SL and strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar,
color=color.green, title="Bullish Setup", size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar,
color=color.red, title="Bearish Setup", size=size.auto)