Strategi crossover purata bergerak adalah strategi perdagangan yang biasa digunakan berdasarkan purata bergerak. Ia menggunakan persilangan purata bergerak yang lebih cepat dan purata bergerak yang lebih perlahan sebagai isyarat perdagangan. Apabila purata bergerak yang lebih cepat melintasi di atas purata bergerak yang lebih perlahan dari bawah, ia adalah isyarat beli. Apabila purata bergerak yang lebih cepat melintasi di bawah purata bergerak yang lebih perlahan dari atas, ia adalah isyarat jual. Strategi ini menggunakan MA 50 hari sebagai MA yang lebih cepat dan MA 200 hari sebagai MA yang lebih perlahan.
Logik teras strategi ini adalah berdasarkan teori purata bergerak. Purata bergerak dapat secara berkesan meratakan turun naik harga dan menunjukkan trend harga. MA yang lebih cepat lebih sensitif terhadap perubahan harga dan dapat menangkap titik pembalikan trend. MA yang lebih perlahan kurang sensitif terhadap perubahan harga dan boleh menapis turun naik jangka pendek. Apabila MA yang lebih cepat melintasi di atas MA yang lebih perlahan, ia menunjukkan trend kenaikan harga. Apabila MA yang lebih cepat melintasi di bawah MA yang lebih perlahan, ia menunjukkan trend penurunan harga.
Secara khusus, strategi ini pertama menentukan MA 50 hari dan MA 200 hari. Syarat kemasukan panjang ditetapkan apabila MA yang lebih cepat melintasi di atas MA yang lebih perlahan. Syarat kemasukan pendek ditetapkan apabila MA yang lebih cepat melintasi di bawah MA yang lebih perlahan. Untuk mengelakkan perdagangan yang bertindih, strategi menggunakan bendera isEntry dan isExit untuk kawalan. Apabila syarat kemasukan dipenuhi, isEntry ditetapkan menjadi benar. Apabila syarat keluar dipenuhi, isExit ditetapkan menjadi benar. Posisi panjang hanya akan dibuka apabila isEntry adalah palsu dan isExit adalah palsu dan isExit adalah sinyal jual.
Di samping itu, strategi ini juga menetapkan tahap mengambil keuntungan dan stop loss. Pengguna boleh menentukan jarak peratusan TP / SL melalui input. Harga TP dan SL akan dikira berdasarkan peratusan harga masuk. Apabila saiz kedudukan lebih besar daripada 0, TP dan SL akan dilaksanakan berdasarkan peratusan panjang TP / SL. Apabila saiz kedudukan kurang dari 0, TP dan SL akan berdasarkan peratusan pendek TP / SL.
Kelebihan strategi ini termasuk:
Mudah dilaksanakan. Ia berdagang semata-mata berdasarkan MA cross, sesuai untuk pemula tanpa pengalaman perdagangan.
Pengurangan yang terkawal dengan pengurusan risiko. purata bergerak boleh menapis turun naik jangka pendek dan mengelakkan berhenti.
Pengguna boleh mengoptimumkan parameter seperti tempoh MA dan tahap TP / SL.
Visualisasi yang jelas. Strategi memetakan MA utama, entri, dan tahap TP / SL pada carta.
Rangka kerja yang boleh diperluaskan. Struktur strategi lengkap. Isyarat dan penunjuk baru boleh ditambah untuk meningkatkannya.
Risiko strategi ini termasuk:
Tidak dapat menghentikan kerugian semasa peristiwa pasaran yang melampau, yang membawa kepada penarikan yang besar. MA yang lebih cepat sensitif terhadap perubahan harga dan mungkin gagal dalam keadaan yang melampau.
Rendah pada pasaran, menyebabkan kerugian berturut-turut.
Kos dagangan tidak dipertimbangkan. Yuran dan slippage dalam dagangan sebenar akan memberi kesan yang ketara kepada keuntungan.
Backtest overfit: Keadaan pasaran sebenar adalah kompleks dan hasil backtest mungkin tidak mewakili prestasi langsung.
Penyelesaian termasuk:
Gunakan stop loss yang lebih luas, atau tambah stop loss tambahan.
Memperluas jarak MA, mengurangkan kekerapan perdagangan, atau menambah penapis lain.
Pertimbangkan kos dagangan sebenar, tetapkan ruang sasaran keuntungan yang lebih luas.
Mengoptimumkan parameter secara beransur-ansur dan mengurangkan pemasangan berlebihan dengan mempertimbangkan keadaan pasaran yang berubah.
Strategi ini boleh dioptimumkan dalam aspek berikut:
Uji kombinasi parameter yang berbeza untuk mencari parameter optimum, seperti tempoh MA.
Tambah penunjuk lain sebagai penapis untuk mengelakkan whipsaws, seperti MACD, KD dll.
Mengoptimumkan strategi stop loss untuk pengurusan risiko yang lebih baik, seperti trailing stop loss.
Meningkatkan saiz kedudukan dengan leverage untuk meningkatkan keuntungan sambil mengawal risiko.
Pertimbangkan kos dagangan, mengoptimumkan parameter untuk dagangan langsung.
Menilai kestabilan parameter menggunakan kaedah statistik untuk mengurangkan pemasangan berlebihan.
Kesimpulannya, strategi crossover MA ini mempunyai logika yang jelas dan mudah dilaksanakan, sesuai sebagai strategi pengenalan untuk perdagangan algo. Tetapi ia juga mempunyai risiko dan batasan. Parameter yang teliti dan pengoptimuman penapis, dan kawalan risiko diperlukan untuk mencapai keuntungan yang mantap. Strategi ini mempunyai keluasan yang besar bagi pengguna untuk berinovasi dan mengoptimumkan berdasarkannya untuk memenuhi gaya perdagangan mereka sendiri.
/*backtest
start: 2023-10-02 00:00:00
end: 2023-10-09 00:00:00
period: 3m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © gjfsdrtytru
//@version=4
strategy("Backtest Engine", "Backtest", overlay=true, commission_type=strategy.commission.percent, commission_value=0.07, initial_capital = 1000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, currency = currency.USD)
// Start code here...
fastMA = sma(close,50)
slowMA = sma(close,200)
plot(fastMA, "Fast MA", color.blue)
plot(slowMA, "Slow MA", color.red)
// Long Enrty/Exit
longCondition = crossover(fastMA,slowMA)
closeLong = crossover(slowMA,fastMA)
// Short Enrty/Exit
shortCondition = crossover(slowMA,fastMA)
closeShort = crossover(fastMA,slowMA)
// Bot web-link alert - {{strategy.order.comment}}
botLONG = "ENTRY LONG ALERT"
botCLOSELONG = "CLOSE LONG ALERT"
botSHORT = "ENTRY SHORT ALERT"
botCLOSESHORT = "CLOSE SHORT ALERT"
//////////////////////////////////////////////////////////////////
//////////////////////// BACKTEST ENGINE \\\\\\\\\\\\\\\\\\\\\\\\\
/////////////////// [NO USER INPUT REQUIRED] /////////////////////
//////////////////////////////////////////////////////////////////
// Time period
testStartYear = input(2020, "Backtest Start Year")
testStartMonth = input(5, "Backtest Start Month")
testStartDay = input(11, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
periodLength = input(3650, "Backtest Period (days)", minval=0,tooltip="Days until strategy ends") * 86400000 // convert days into UNIX time
testPeriodStop = testPeriodStart + periodLength
testPeriod() =>
time >= testPeriodStart and time <= testPeriodStop ? true : false
// Convert Take profit and Stop loss to percentage
longTP = input(title="Long Take Profit (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
longSL = input(title="Long Stop Loss (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
shortTP = input(title="Short Take Profit (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
shortSL = input(title="Short Stop Loss (%)", type=input.float, minval=0.0, step=0.1, defval=0) * 0.01 // Set levels with input options
// 0% TP/SL = OFF (a value of 0 turns off TP/SL feature)
longProfitPerc = longTP == 0 ? 1000 : longTP
longStopPerc = longSL == 0 ? 1 : longSL
shortProfitPerc = shortTP == 0 ? 1 : shortTP
shortStopPerc = shortSL == 0 ? 1000 : shortSL
// Determine TP/SL price based on percentage given
longProfitPrice = strategy.position_avg_price * (1 + longProfitPerc)
longStopPrice = strategy.position_avg_price * (1 - longStopPerc)
shortProfitPrice = strategy.position_avg_price * (1 - shortProfitPerc)
shortStopPrice = strategy.position_avg_price * (1 + shortStopPerc)
// Anti-overlap
isEntry_Long = false
isEntry_Long := nz(isEntry_Long[1], false)
isExit_Long = false
isExit_Long := nz(isExit_Long[1], false)
isEntry_Short = false
isEntry_Short := nz(isEntry_Short[1], false)
isExit_Short = false
isExit_Short := nz(isExit_Short[1], false)
entryLong = not isEntry_Long and longCondition
exitLong = not isExit_Long and closeLong
entryShort = not isEntry_Short and shortCondition
exitShort = not isExit_Short and closeShort
if (entryLong)
isEntry_Long := true
isExit_Long := false
if (exitLong)
isEntry_Long := false
isExit_Long := true
if (entryShort)
isEntry_Short := true
isExit_Short := false
if (exitShort)
isEntry_Short := false
isExit_Short := true
// Order Execution
if testPeriod()
if entryLong
strategy.entry(id="Long", long=true, when = entryLong, comment=botLONG) // {{strategy.order.comment}}
if entryShort
strategy.entry(id="Short", long=false, when = entryShort, comment=botSHORT) // {{strategy.order.comment}}
// TP/SL Execution
if (strategy.position_size > 0)
strategy.exit(id="Long SL/TP", from_entry="Long", limit=longProfitPrice, stop=longStopPrice)
strategy.close(id="Long", when=exitLong, comment=botCLOSELONG) // {{strategy.order.comment}}
if (strategy.position_size < 0)
strategy.exit(id="Short TP/SL", from_entry="Short", limit=shortProfitPrice, stop=shortStopPrice)
strategy.close(id="Short", when=exitShort, comment=botCLOSESHORT) // {{strategy.order.comment}}
// Draw Entry, TP and SL Levels for Long Positions
plot(strategy.position_size > 0 ? longTP == 0 ? na : longProfitPrice : na, style=plot.style_linebr, color=color.green, title="Long TP")
plot(strategy.position_size > 0 ? strategy.position_avg_price : na, style=plot.style_linebr, color=color.blue, title="Long Entry")
plot(strategy.position_size > 0 ? longSL == 0 ? na : longStopPrice : na, style=plot.style_linebr, color=color.red, title="Long SL")
// Draw Entry, TP and SL Levels for Short Positions
plot(strategy.position_size < 0 ? shortTP == 0 ? na : shortProfitPrice : na, style=plot.style_linebr, color=color.green, title="Short TP")
plot(strategy.position_size < 0 ? strategy.position_avg_price : na, style=plot.style_linebr, color=color.blue, title="Short Entry")
plot(strategy.position_size < 0 ? shortSL == 0 ? na : shortStopPrice : na, style=plot.style_linebr, color=color.red, title="Short SL")