Sumber daya yang dimuat... Pemuatan...
  1. Persegi
  2. Strategi naik/turun berturut-turut dengan perpanjangan Reverse dan SL/TP

Strategi naik/turun berturut-turut dengan perpanjangan Reverse dan SL/TP

Penulis:ChaoZhang, Tanggal: 2024-01-08 11:58:21
Tag:

img

Gambaran umum

Strategi ini adalah perpanjangan dari strategi up/down bar berturut-turut yang dibangun di TradingView. Ini memiliki pengaturan arah yang fleksibel yang memungkinkan perdagangan terbalik. Juga, terintegrasi dengan berbagai metode stop loss seperti swing point/low, ATR stop, dan strategi stop, serta mengambil pengaturan keuntungan sesuai. Ini membuat strategi lebih baik dalam manajemen risiko sambil menjaga sinyal perdagangan asli.

Logika Strategi

Strategi ini terutama menggunakan bar naik atau turun berturut-turut untuk menghasilkan sinyal beli dan jual. Pengguna dapat mengkonfigurasi bar naik berturut-turut yang diperlukan untuk sinyal beli, dan bar turun berturut-turut untuk sinyal jual.

Dengan mengaktifkannya, sinyal beli asli menjadi sinyal jual, dan sebaliknya, sehingga menyelesaikan pembalikan perdagangan.

Untuk masuk dan keluar, posisi terbalik langsung didukung untuk mengurangi waktu tanpa posisi.

Untuk stop loss dan take profit, swing point/low, ATR stop dan strategi stop disediakan untuk pilihan. Metode stop loss akan dikombinasikan dengan arah posisi untuk memilih swing low atau high sebagai stop agresif, atau menggunakan ATR untuk secara dinamis mendefinisikan harga stop. Take profit menetapkan jarak tetap berdasarkan harga masuk.

Jika trailing stop diaktifkan, strategi dapat melonggarkan jarak stop saat kalah, dan memperketat saat mendapatkan keuntungan.

Analisis Keuntungan

Keuntungan terbesar dari strategi ini adalah fleksibilitas untuk beradaptasi dengan kondisi pasar yang berbeda:

  1. Parameter filter beli/jual dapat diatur untuk pasar tren dan pasar bervariatif
  2. Perdagangan terbalik memungkinkan pilihan arah bila diperlukan
  3. Posisi terbalik langsung mengurangi waktu tanpa posisi
  4. Beberapa metode stop loss, pilih sesuai kebutuhan
  5. Hentikan pengangkut tersedia untuk efek otomatis

Analisis Risiko

Risiko utama adalah terlalu banyak bar berturut-turut yang menyebabkan perdagangan yang hilang, dan stop loss yang agresif yang menyebabkan kerugian yang diperpanjang.

  1. Sesuaikan jumlah batang ke atas/ke bawah secara moderat, tidak terlalu agresif
  2. Uji metode stop loss yang berbeda, temukan yang paling cocok
  3. Gunakan trailing stop dengan hati-hati, menghindari kerugian yang terlalu besar

Arahan Optimasi

Ada ruang untuk optimasi lebih lanjut:

  1. Mengatur bar naik/turun secara dinamis berdasarkan ATR atau volatilitas
  2. Test stop loss/profit ratio dalam periode kepemilikan yang berbeda
  3. Tambahkan filter harga terbuka untuk menghindari pecah palsu
  4. Mengintegrasikan indikator lain untuk kualitas sinyal yang lebih baik

Kesimpulan

Strategi ini membuat ekstensi yang menguntungkan untuk strategi dasar untuk kontrol risiko yang lebih baik dan perdagangan yang lebih fleksibel.

/*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)
Lebih banyak

2019 FMZ - Semua hak dilindungi