Stratégie de stop-profit et de stop-loss Momentum bidirectionnelle
ChaoZhang
Aperçu
Cette stratégie est une extension de la stratégie de hausse / baisse continue intégrée à TradingView. Elle dispose d’un réglage de direction stratégique flexible qui permet de négocier à contre-courant. Elle intègre également plusieurs modes de stop, tels que le swing high / low, le stop ATR et le stop tracking, ainsi que les paramètres de stop correspondants.
Principe de stratégie
La stratégie consiste principalement à déterminer le nombre d’augmentations ou de baisses successives des lignes K, générant des signaux d’achat et de vente. L’utilisateur peut définir le nombre de lignes K successives d’augmentation ou de baisse nécessaires pour générer un signal d’achat et le nombre de lignes K successives de baisse nécessaires pour un signal de vente.
En même temps, la stratégie a ajouté des paramètres pour inverser les transactions. Après avoir lancé une transaction inverse, le signal d’achat original devient un signal de vente, et le signal de vente devient également un signal d’achat, ce qui complète le renversement des transactions.
Pour les entrées et les sorties, la stratégie prend en charge la position directe inverse de la plage, ce qui réduit le risque de non-commercialisation en cas d’absence de position.
En ce qui concerne les arrêts et les arrêts, la stratégie fournit trois options de stop qui permettent d’échanger les hauts / bas, l’ATR et la stratégie intégrée. Les arrêts sont combinés avec la direction de la position, en choisissant automatiquement la plus basse ou la plus haute vallée comme arrêt radical, ou en déterminant le prix de stop en fonction de la dynamique de l’ATR. Le paramètre d’arrêt est basé sur le prix d’entrée de la stratégie et définit une distance d’arrêt de multiples fixes.
Si le suivi des arrêts est activé, la stratégie peut augmenter l’intervalle d’arrêt en cas de perte et réduire l’intervalle d’arrêt en cas de profit, permettant un suivi automatique.
Analyse des avantages
Le plus grand avantage de cette stratégie réside dans la flexibilité de configuration, qui peut s’adapter à différentes conditions de marché, avec les avantages suivants:
- Paramètres de filtrage de vente et d’achat réglables, adaptés aux tendances et aux chocs
- Prise en charge des échanges inversés selon les besoins
- La mise en place d’une ouverture de position directe à l’envers réduit les périodes sans position
- Intégration de plusieurs modes de réduction des pertes, selon les besoins
- Tracking Stop Loss, Stop Loss automatique est activé
Analyse des risques
Les principaux risques de cette stratégie résident dans le fait qu’un réglage excessif de lignes K en continu peut entraîner des opportunités de transactions manquées, ainsi que le risque d’une expansion des pertes en raison d’un réglage de stop-loss trop radical. Les recommandations pour les risques sont les suivantes:
- Ajustez les paramètres de montée/baisse du nombre de lignes K, ne soyez pas trop radical
- Tester différentes méthodes de prévention et choisir la plus appropriée
- Le suivi des arrêts de perte doit être mis en place avec prudence pour éviter des pertes excessives.
Direction d’optimisation
Il y a encore de la place pour optimiser cette stratégie:
- Le nombre de lignes K à la hausse/à la baisse peut être ajusté dynamiquement en fonction d’indicateurs tels que l’ATR ou la volatilité
- On peut tester l’effet des paramètres du stop loss/stop loss ratio sur différentes périodes de détention.
- Le filtre Open peut être défini pour éviter les fausses intrusions.
- On peut ajouter d’autres indicateurs auxiliaires pour améliorer la qualité du signal.
Résumer
Cette stratégie est une extension bénéfique de la stratégie de référence, qui permet de mieux contrôler les risques et d’obtenir une méthode de négociation plus flexible. C’est une stratégie de Momentum efficace, facile à optimiser et à mettre en œuvre.
/*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)