Sumber dimuat naik... memuat...
  1. Persegi
  2. Strategi berturut-turut ke atas / ke bawah dengan pemindahan ke belakang dan SL / TP

Strategi berturut-turut ke atas / ke bawah dengan pemindahan ke belakang dan SL / TP

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

img

Ringkasan

Strategi ini adalah lanjutan daripada strategi bar naik/turun berturut-turut yang terbina dalam TradingView. Ia mempunyai tetapan arah yang fleksibel yang membolehkan perdagangan terbalik. Juga, bersepadu dengan pelbagai kaedah stop loss seperti titik ayunan / rendah, berhenti ATR, dan strategi berhenti, serta mengambil tetapan keuntungan dengan sewajarnya. Ini menjadikan strategi lebih baik dalam pengurusan risiko sambil mengekalkan isyarat perdagangan asal.

Logika Strategi

Strategi ini terutamanya menggunakan bar naik atau turun berturut-turut untuk menjana isyarat beli dan jual. Pengguna boleh mengkonfigurasi bar naik berturut-turut yang diperlukan untuk isyarat beli, dan bar turun berturut-turut untuk isyarat jual.

Juga, pilihan perdagangan terbalik ditambahkan. Dengan mengaktifkannya, isyarat beli asal menjadi isyarat jual, dan sebaliknya, dengan itu melengkapkan pembalikan perdagangan.

Untuk kemasukan dan keluar, kedudukan terbalik terus disokong untuk mengurangkan masa tanpa kedudukan.

Untuk stop loss dan mengambil keuntungan, titik swing / rendah, ATR berhenti dan strategi berhenti disediakan untuk pilihan. Kaedah stop loss akan digabungkan dengan arah kedudukan untuk memilih swing rendah atau tinggi sebagai berhenti agresif, atau menggunakan ATR untuk menentukan harga berhenti secara dinamik. Ambil keuntungan menetapkan jarak tetap berdasarkan harga kemasukan.

Jika penangguhan belakang diaktifkan, strategi boleh melonggarkan jarak berhenti apabila kehilangan, dan mengetatkan apabila keuntungan.

Analisis Kelebihan

Kelebihan terbesar strategi ini adalah fleksibiliti untuk menyesuaikan diri dengan keadaan pasaran yang berbeza:

  1. Parameter penapis beli / jual boleh ditetapkan untuk kedua-dua pasaran trend dan julat
  2. Perdagangan terbalik membolehkan pilihan arah apabila diperlukan
  3. Kedudukan terbalik langsung mengurangkan masa tanpa kedudukan
  4. Kaedah stop loss berbilang, pilih mengikut keperluan
  5. Hentikan pengangkutan untuk kesan automatik

Analisis Risiko

Risiko utama adalah terlalu banyak bar berturut-turut yang membawa kepada perdagangan yang hilang, dan kerugian berhenti yang agresif yang menyebabkan kerugian yang diperpanjang.

  1. Sesuaikan ke atas / ke bawah bar kuantiti sederhana, tidak terlalu agresif
  2. Uji kaedah stop loss yang berbeza, cari yang paling sesuai
  3. Gunakan hentian dengan berhati-hati, mengelakkan kerugian yang terlalu besar

Arahan pengoptimuman

Terdapat ruang untuk pengoptimuman lanjut:

  1. Sesuaikan bar naik/turun secara dinamik berdasarkan ATR atau volatiliti
  2. Rasio kerugian/keuntungan henti ujian dalam tempoh pegangan yang berbeza
  3. Tambah penapis harga terbuka untuk mengelakkan pecah palsu
  4. Mengintegrasikan penunjuk lain untuk kualiti isyarat yang lebih baik

Kesimpulan

Strategi ini membuat pelanjutan yang bermanfaat kepada strategi asas untuk kawalan 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 lanjut

2019 FMZ - Semua hak dilindungi