Strategi perdagangan kuantitatif dari tiga persilangan rata-rata bergerak + indikator William
ChaoZhang
Ringkasan
Strategi ini mengidentifikasi arah tren harga saham dengan menggabungkan tiga rata-rata bergerak lurus, indeks relatif kuat (RSI) dan indikator William, dan mencari peluang masuk ketika tren berbalik. Ketika tiga rata-rata bergerak bergerak ke atas (RSI) berbaris, RSI lebih tinggi (RSI) lebih rendah (RSI) dari 50, dan muncul sinyal indikator William ke bawah (RSI) ke atas, lakukan lebih banyak (RSI) kosong.
Prinsip Strategi
Strategi ini menggunakan tiga rata-rata bergerak halus dari tiga periode yang berbeda, termasuk garis cepat, garis tengah, dan garis lambat. Ketika garis cepat melewati garis tengah, harga saham masuk ke tren naik; Ketika garis cepat melewati garis tengah, harga saham masuk ke tren turun.
Secara khusus, setelah harga saham memasuki tren naik, strategi ini akan menunggu lima kondisi berikut ini terpenuhi secara bersamaan sebelum membuka posisi lebih banyak:
- Garis cepat, tengah, dan lambat semuanya ke atas.
- RSI lebih tinggi dari 50;
- Ini adalah bentuk William yang muncul ke bawah.
- Harga saham naik dengan cepat.
- Tidak ada posisi saat ini.
Setelah harga saham masuk ke tren turun, strategi akan menunggu lima kondisi berikut ini terpenuhi secara bersamaan sebelum membuka posisi shorting:
- Garis cepat, tengah, dan lambat semuanya ke bawah.
- RSI di bawah 50;
- Ini adalah bentuk William yang muncul ke atas.
- Harga saham di bawah garis lambat;
- Tidak ada posisi saat ini.
Setelah melakukan shorting lebih banyak, strategi akan mengatur stop loss dan stop loss untuk mengendalikan risiko. Secara khusus, stop loss adalah persentase tertentu dari harga masuk dan stop loss adalah harga setelah harga masuk bergerak ke arah yang menguntungkan.
Keunggulan Strategis
Kombinasi berbagai indikator untuk mengkonfirmasi masuk, dapat secara efektif mencegah terobosan palsu. Tiga garis lurus menentukan arah tren, indikator William menangkap sinyal reversal, RSI memfilter gerakan getaran, bersama-sama meningkatkan akurasi masuk.
Dengan pengaturan stop loss, Anda dapat mengontrol rasio risiko-keuntungan dari setiap transaksi, sehingga memastikan bahwa perdagangan yang menguntungkan lebih besar daripada perdagangan yang merugikan.
Logika strategi yang jelas dan mudah dipahami, parameter yang diatur dengan baik, cocok untuk digunakan oleh trader di berbagai tingkatan.
Risiko Strategis
Dalam situasi yang bergoyang, indikator dapat mengirimkan sinyal yang salah, yang menyebabkan masuk yang tidak perlu. Anda dapat menyaring sebagian dari situasi yang bergoyang dengan mengoptimalkan parameter RSI.
Intersection of fast and intermediate lines dapat menyebabkan false breaks, dan harus digunakan bersama dengan indikator lain. Anda dapat mempertimbangkan untuk menambahkan indikator volume transaksi.
Stop loss yang terlalu dekat dengan harga masuk dapat menyebabkan stop loss keluar, dan pengaturan stop loss harus disesuaikan dengan posisi yang tepat.
Stop-point yang terlalu jauh dari harga masuk mungkin tidak dapat menghentikan pertandingan, dan stop-point harus disesuaikan ke posisi yang tepat.
Arah optimasi strategi
Kombinasi parameter dapat diuji untuk periode yang berbeda, untuk mengoptimalkan tiga garis rata-rata dan parameter RSI
Indikator lain dapat ditambahkan, seperti indikator volume transaksi, untuk menilai apakah volume transaksi menonjol sebelum terobosan.
Pengaturan parameter untuk strategi ini dapat diuji berdasarkan varietas yang berbeda.
Dapat memetakan kurva keuntungan berdasarkan hasil pengukuran, dan menguji pengaturan parameter stop loss.
Anda dapat mencoba melakukan simulasi perdagangan dan mengoptimalkan pengaturan parameter sebelum mengaktifkan.
Meringkaskan
Strategi ini secara keseluruhan logis dan jelas, menggunakan kombinasi indikator untuk masuk dan keluar, dapat secara efektif mengendalikan risiko. Ada banyak ruang untuk mengoptimalkan parameter strategi, dengan menguji pengaturan parameter yang berbeda, strategi ini dapat menjadi strategi perdagangan kuantitatif yang menguntungkan secara stabil.
/*backtest
start: 2023-08-28 00:00:00
end: 2023-09-27 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//This script is a combination of 3 smoothed moving averages, and RSI. When moving averages are aligned upward (downward) and RSI is above (below) 50 and a down (up) William fractal appears, it enters long (short) position. Exiting from long and short entries are defined by StopLoss and TargetProfit.
//@version=5
strategy(title="3SmmaCrossUp + Fractal + RSI", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100, currency=currency.USD, commission_type=strategy.commission.percent, commission_value=0.03)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// inputs
// Global
src = input(close, title="Source")
stopLoss = input.float(defval = 0.1, title = "Stop Loss %", minval = 0, maxval=100, step = 0.1)
targetProfit = input.float(defval = 0.4, title = "Target Profit %", minval = 0, maxval=100, step = 0.1)
// Smooth Moving Average
fastSmmaLen = input.int(21, minval=1, title="Fast Length", group = "Smooth Moving Average")
midSmmaLen = input.int(50, minval=1, title="Mid Length",group = "Smooth Moving Average")
slowSmmaLen = input.int(200, minval=1, title="Slow Length",group = "Smooth Moving Average")
// RSI
rsiLen = input.int(defval=14, title="length", minval=1, maxval=1000, step=1, group="RSI")
// Fractals
n = input.int(title="Periods", defval=2, minval=2, group = "Fractals")
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// initialization
var waitingFirstTradeInUpwardTrend = false
var waitingFirstTradeInDownwardTrend = false
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// functions
smma(ma, src, len) =>
smma = 0.0
smma := na(smma[1]) ? ma : (smma[1] * (len - 1) + src) / len
smma
fractals(n, highs, lows) =>
// UpFractal
bool upflagDownFrontier = true
bool upflagUpFrontier0 = true
bool upflagUpFrontier1 = true
bool upflagUpFrontier2 = true
bool upflagUpFrontier3 = true
bool upflagUpFrontier4 = true
for i = 1 to n
upflagDownFrontier := upflagDownFrontier and (highs[n-i] < highs[n])
upflagUpFrontier0 := upflagUpFrontier0 and (highs[n+i] < highs[n])
upflagUpFrontier1 := upflagUpFrontier1 and (highs[n+1] <= highs[n] and highs[n+i + 1] < highs[n])
upflagUpFrontier2 := upflagUpFrontier2 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+i + 2] < highs[n])
upflagUpFrontier3 := upflagUpFrontier3 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+i + 3] < highs[n])
upflagUpFrontier4 := upflagUpFrontier4 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+4] <= highs[n] and highs[n+i + 4] < highs[n])
flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4
upFractal = (upflagDownFrontier and flagUpFrontier)
// downFractal
bool downflagDownFrontier = true
bool downflagUpFrontier0 = true
bool downflagUpFrontier1 = true
bool downflagUpFrontier2 = true
bool downflagUpFrontier3 = true
bool downflagUpFrontier4 = true
for i = 1 to n
downflagDownFrontier := downflagDownFrontier and (lows[n-i] > lows[n])
downflagUpFrontier0 := downflagUpFrontier0 and (lows[n+i] > lows[n])
downflagUpFrontier1 := downflagUpFrontier1 and (lows[n+1] >= lows[n] and lows[n+i + 1] > lows[n])
downflagUpFrontier2 := downflagUpFrontier2 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+i + 2] > lows[n])
downflagUpFrontier3 := downflagUpFrontier3 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+i + 3] > lows[n])
downflagUpFrontier4 := downflagUpFrontier4 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+4] >= lows[n] and lows[n+i + 4] > lows[n])
flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4
downFractal = (downflagDownFrontier and flagDownFrontier)
[upFractal, downFractal]
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// calcs
[upFractal, downFractal] = fractals(n, high, low)
rsiIsHigh = ta.rsi(src, rsiLen) >= 50
slowMa = ta.sma(src, slowSmmaLen)
midMa = ta.sma(src, midSmmaLen)
fastMa = ta.sma(src, fastSmmaLen)
slowSmma = smma(slowMa ,src, slowSmmaLen)
midSmma = smma(midMa, src, midSmmaLen)
fastSmma = smma(fastMa, src, fastSmmaLen)
isFastSmmaUpward = ta.rising(fastSmma, 1)
isMidSmmaUpward = ta.rising(midSmma, 1)
isSlowSmmaUpward = ta.rising(slowSmma, 1)
isFastSmmaDownward = ta.falling(fastSmma, 1)
isMidSmmaDownward = ta.falling(midSmma, 1)
isSlowSmmaDownward = ta.falling(slowSmma, 1)
slowMovingAveragesAreUpward = isMidSmmaUpward and isSlowSmmaUpward
slowMovingAveragesAreDownward = isMidSmmaDownward and isSlowSmmaDownward
justEnteredUpwardTrend = ta.crossover(fastSmma, midSmma) ? true : false
justEnteredDownwardTrend = ta.crossunder(fastSmma, midSmma) ? true : false
waitingFirstTradeInUpwardTrend := justEnteredUpwardTrend == true ? true : (isFastSmmaDownward or isMidSmmaDownward or isSlowSmmaDownward ? false : waitingFirstTradeInUpwardTrend)
waitingFirstTradeInDownwardTrend := justEnteredDownwardTrend == true ? true : (isFastSmmaUpward or isMidSmmaUpward or isSlowSmmaUpward ? false : waitingFirstTradeInDownwardTrend)
priceCrossedOverSlowMa = ta.crossover(close, slowSmma)
priceCrossedUnderSlowMa = ta.crossunder(close, slowSmma)
enterLongCondition = barstate.isconfirmed and low > fastSmma and rsiIsHigh and (downFractal or priceCrossedOverSlowMa) and waitingFirstTradeInUpwardTrend and strategy.position_size == 0
enterShortCondition = barstate.isconfirmed and high < fastSmma and (not rsiIsHigh) and (upFractal or priceCrossedUnderSlowMa) and waitingFirstTradeInDownwardTrend and strategy.position_size == 0
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// strategy
if(enterLongCondition)
strategy.entry(id="L", direction=strategy.long)
waitingFirstTradeInUpwardTrend := false
if(enterShortCondition)
strategy.entry(id="S", direction=strategy.short)
waitingFirstTradeInDownwardTrend := false
if(strategy.position_size > 0)
strategy.exit(id="EL", stop=strategy.position_avg_price * (1 - stopLoss/100), limit=strategy.position_avg_price * (1+targetProfit/100))
if(strategy.position_size < 0)
strategy.exit(id="ES", stop=strategy.position_avg_price * (1 + stopLoss/100), limit=strategy.position_avg_price * (1-targetProfit/100))
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// plots
plot(series = slowSmma, title="Slow SMMA", linewidth=3)
plot(series = midSmma, title="Mid SMMA", linewidth=2)
plot(series = fastSmma, title="Fast SMMA", linewidth=1)
plotchar(series=rsiIsHigh, title='rsiIsHigh', char='')
plotchar(series=justEnteredUpwardTrend, title='justEnteredUpwardTrend', char='')
plotchar(series=justEnteredDownwardTrend, title='justEnteredDownwardTrend', char='')
plotchar(series=waitingFirstTradeInUpwardTrend, title='waitingFirstTradeInUpwardTrend', char='')
plotchar(series=waitingFirstTradeInDownwardTrend, title='waitingFirstTradeInDownwardTrend', char='')
plotchar(series=enterLongCondition, title='enterLongCondition' , char='')
plotchar(series=enterShortCondition, title='enterShortCondition' , char='')
plotshape(series=upFractal, title='upFractal', style=shape.triangleup, location=location.abovebar, color=#009688, size = size.tiny)
plotshape(series=downFractal, title='downFractal', style=shape.triangledown, location=location.belowbar, color=color.red, size = size.tiny)