Strategi stop-profit dan stop-loss momentum dua arah
ChaoZhang
Ringkasan
Strategi ini adalah perpanjangan dari strategi naik/turun berurutan yang ada di TradingView. Strategi ini memiliki pengaturan arah strategi yang fleksibel untuk melakukan trading mundur. Strategi ini juga mengintegrasikan berbagai cara stop loss seperti swing high/low, ATR stop loss dan tracking stop loss, serta pengaturan stop loss yang sesuai.
Prinsip Strategi
Strategi ini terutama menghasilkan sinyal beli dan jual dengan menilai berapa kali K-line naik atau turun secara berturut-turut. Pengguna dapat mengatur berapa kali K-line naik secara berturut-turut diperlukan untuk menghasilkan sinyal beli, dan berapa kali K-line turun secara berturut-turut diperlukan untuk sinyal jual.
Pada saat yang sama, strategi ini menambahkan pengaturan untuk membalikkan perdagangan. Setelah memulai perdagangan reverse, sinyal beli akan berubah menjadi sinyal jual, dan sinyal jual juga akan berubah menjadi sinyal beli, sehingga pembalikan perdagangan selesai.
Pada entry dan exit, strategi ini mendukung posisi lurus kebalik pada posisi kosong, yang dapat mengurangi ketidakmampuan untuk berdagang ketika tidak ada posisi.
Dalam hal stop loss dan stop loss, strategi ini menawarkan tiga pilihan stop loss yang dapat diputar dengan posisi tinggi / rendah, ATR, dan strategi yang dibangun. Stop loss dapat dikombinasikan dengan arah memegang posisi, secara otomatis memilih terendah atau teratas sebagai stop loss yang dinamis, atau menentukan harga stop loss berdasarkan dinamika ATR.
Jika Anda mengaktifkan pelacakan stop loss, strategi ini dapat meningkatkan stop loss jika Anda mengalami kerugian, dan mengurangi stop loss jika Anda mendapatkan keuntungan, untuk melakukan pelacakan otomatis.
Analisis Keunggulan
Keuntungan terbesar dari strategi ini adalah fleksibilitas yang dapat disesuaikan dengan kondisi pasar yang berbeda, seperti berikut:
- Parameter penyaringan yang dapat disetel untuk beradaptasi dengan tren dan kondisi yang bergejolak
- Mendukung perdagangan reverse, dapat memilih arah sesuai kebutuhan
- Pengaturan untuk membuka posisi langsung dengan cara mundur, dapat mengurangi periode tanpa posisi
- Terintegrasi berbagai modus stop loss, dapat dipilih sesuai kebutuhan
- Tracking stop loss, stop loss otomatis dapat diaktifkan
Analisis risiko
Risiko utama dari strategi ini adalah bahwa terlalu banyak pengaturan K-line secara berturut-turut dapat menyebabkan peluang perdagangan yang terlewatkan, dan risiko bahwa pengaturan stop loss yang terlalu radikal dapat menyebabkan peningkatan kerugian. Saran untuk risiko adalah sebagai berikut:
- Menyesuaikan parameter jumlah garis K naik/turun, jangan terlalu radikal
- Uji coba berbagai metode penghentian kerugian dan pilih yang paling sesuai
- Tracking Stop Loss harus diatur dengan hati-hati untuk menghindari kerugian yang berlebihan
Arah optimasi
Strategi ini masih bisa dioptimalkan lebih jauh:
- Jumlah garis K naik/turun yang dapat disesuaikan secara dinamis berdasarkan ATR atau volatilitas
- Dapat menguji efek parameter stop loss stop loss rasio pada waktu pemegang posisi yang berbeda
- Anda dapat mengatur filter terbuka untuk menghindari penembusan palsu.
- Anda dapat menambahkan indikator tambahan untuk meningkatkan kualitas sinyal.
Meringkaskan
Strategi ini merupakan perluasan yang bermanfaat dari strategi acuan yang memungkinkan pengendalian risiko yang lebih baik dan akses ke metode perdagangan yang lebih fleksibel. Ini adalah strategi Momentum yang efektif yang mudah dioptimalkan dan dioperasikan.
/*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)