1. Carré
  2. Stratégie ascendante/abaissante consécutive avec extension inverse et SL/TP

Stratégie ascendante/abaissante consécutive avec extension inverse et SL/TP

Auteur:ChaoZhang est là., Date: 2024-01-08 11:58:21 Le projet de loi est en cours d'adoption.
Les étiquettes:

img

Résumé

Cette stratégie est une extension de la stratégie de barres ascendantes/abaissantes consécutives intégrée sur TradingView. Elle possède des réglages de direction flexibles qui permettent le trading inverse. Elle est également intégrée à diverses méthodes de stop loss comme les points d'oscillation / bas, le stop ATR et le stop de stratégie, ainsi que des réglages de profit en conséquence.

La logique de la stratégie

La stratégie utilise principalement les barres ascendantes ou descendantes consécutives pour générer des signaux d'achat et de vente.

En l'activant, les signaux d'achat d'origine deviennent des signaux de vente, et vice versa, complétant ainsi l'inversion du commerce.

Pour les entrées et sorties, l'inversion de position directe est prise en charge pour réduire le temps sans position.

Pour le stop loss et le take profit, des points de swing/low, un stop ATR et un stop stratégique sont fournis pour le choix. La méthode de stop loss se combinera avec la direction de la position pour choisir le swing low ou high comme stop agressif, ou utiliser ATR pour définir dynamiquement le prix stop.

Si l'arrêt de trailing est activé, la stratégie peut assouplir la distance d'arrêt en cas de perte et se resserrer en cas de profit.

Analyse des avantages

L'avantage majeur de cette stratégie est la souplesse d'adaptation aux différentes conditions du marché:

  1. Les paramètres du filtre achat/vente peuvent être définis pour les marchés à tendance et à fourchette
  2. Le commerce inverse permet le choix de la direction au besoin
  3. La position inverse directe réduit le temps sans position
  4. Méthodes de stop loss multiples, sélectionnées selon les besoins
  5. Arrêt de traction disponible pour effet automatique

Analyse des risques

Les principaux risques sont trop de barres consécutives conduisant à des transactions manquantes et un stop loss agressif entraînant des pertes prolongées.

  1. Ajustez la quantité de barres vers le haut/vers le bas modérément, pas trop agressif
  2. Testez différentes méthodes de stop loss, trouvez la meilleure
  3. Utilisez l'arrêt de trail prudemment, éviter les pertes trop grandes

Directions d'optimisation

Il est possible d'optimiser davantage:

  1. Ajustez dynamiquement les barres vers le haut/vers le bas en fonction de l'ATR ou de la volatilité
  2. Ratio de perte/bénéfice de test-stop au cours de différentes périodes de détention
  3. Ajouter un filtre de prix ouvert pour éviter une fausse rupture
  4. Intégrer d'autres indicateurs pour une meilleure qualité du signal

Conclusion

Cette stratégie comporte des extensions bénéfiques à la stratégie de base pour un meilleur contrôle des risques et une négociation plus flexible.

/*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)
Plus de

2019 FMZ - Tous les droits réservés