Strategi ini mengenal pasti arah trend harga dengan menggabungkan tiga purata bergerak yang halus, indeks kekuatan relatif (RSI) dan penunjuk Williams, dan mencari peluang perdagangan apabila trend berbalik. Ia pergi panjang (pendek) apabila purata bergerak pantas, sederhana dan perlahan sejajar ke atas (ke bawah), RSI di atas (di bawah) 50 dan isyarat Williams ke bawah (ke atas) muncul. Stop loss ditetapkan pada peratusan tertentu daripada harga kemasukan, dan mengambil keuntungan pada pergerakan peratusan tertentu ke arah yang menguntungkan dari harga kemasukan.
Strategi ini menggunakan tiga purata bergerak dengan tempoh yang berbeza, termasuk MA pantas, sederhana dan perlahan. Apabila MA pantas melintasi MA sederhana, ia menandakan trend harga menaik. Apabila MA pantas melintasi di bawah MA sederhana, ia menandakan trend harga menurun. Selepas mengenal pasti trend menaik atau menurun, strategi menunggu peluang perdagangan pertama.
Khususnya, selepas harga memasuki trend menaik, strategi menunggu sehingga lima syarat berikut dipenuhi sebelum pergi panjang:
MAs pantas, sederhana dan perlahan semuanya menunjuk ke atas;
RSI melebihi 50;
Satu corak Williams ke bawah muncul;
Harga melintasi MA perlahan;
Tiada kedudukan semasa.
Selepas harga memasuki trend penurunan, strategi menunggu sehingga lima syarat berikut dipenuhi sebelum pergi pendek:
MAs pantas, sederhana dan perlahan semuanya menunjuk ke bawah;
RSI di bawah 50;
Satu corak Williams ke atas muncul;
Harga melintasi di bawah MA perlahan;
Tiada kedudukan semasa.
Selepas pergi panjang atau pendek, strategi menetapkan stop loss pada peratusan tertentu di bawah harga kemasukan, dan sasaran mengambil keuntungan pada peratusan tertentu di atas harga kemasukan.
Menggabungkan beberapa penunjuk untuk mengesahkan entri dapat dengan berkesan mengelakkan pecah palsu. MAs tiga kali mengesan arah trend, Williams menangkap isyarat pembalikan, dan RSI menapis tindakan harga yang terikat julat, bersama-sama meningkatkan ketepatan entri.
Menetapkan stop loss dan mengambil keuntungan boleh mengawal risiko / ganjaran setiap perdagangan, memastikan perdagangan yang menang melebihi perdagangan yang rugi.
Logik strategi adalah jelas dan mudah difahami. Parameter ditetapkan dengan munasabah. Ia sesuai dengan peniaga pada tahap yang berbeza.
Indikator boleh menghasilkan isyarat yang salah semasa pasaran terhad julat, menyebabkan entri yang tidak perlu.
Perpindahan MA yang cepat dan sederhana mungkin mempunyai pecah palsu.
Jika stop loss terlalu dekat dengan harga kemasukan, ia mungkin akan dihentikan lebih awal. Stop loss harus diselaraskan ke kedudukan yang betul.
Jika keuntungan mengambil terlalu jauh dari harga masuk, ia mungkin tidak akan dipukul.
Uji kombinasi parameter yang berbeza untuk tiga MA dan RSI.
Tambah penunjuk lain, seperti jumlah, untuk memeriksa sama ada jumlah meningkat pada pecah.
Parameter ujian berdasarkan produk yang berbeza.
Menggambar lengkung keuntungan berdasarkan hasil backtest untuk mengoptimumkan stop loss dan mengambil keuntungan.
Cuba perdagangan kertas sebelum membolehkan ia untuk mengoptimumkan parameter.
Strategi ini mempunyai logik yang jelas secara keseluruhan, memasuki dan keluar dari kedudukan dengan gabungan penunjuk, yang berkesan mengawal risiko. Terdapat ruang yang besar untuk pengoptimuman parameter. Dengan menguji tetapan parameter yang berbeza, strategi ini boleh menjadi strategi perdagangan kuantitatif yang menguntungkan yang mantap. Walau bagaimanapun, tidak ada strategi yang dapat mengelakkan kerugian sepenuhnya. Pedagang perlu mengikuti disiplin perdagangan - mengambil keuntungan apabila menang dan memotong kerugian apabila kalah.
/*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)