Strategi Crossover Rata-rata Pergerakan Sudut Tren
ChaoZhang
Ringkasan
Strategi ini dilakukan dengan menghitung sudut kemiringan garis rata-rata, menentukan arah tren, digabungkan dengan indikator perubahan tingkat harga, untuk melakukan perdagangan dua arah. Intinya adalah menggunakan sudut kemiringan garis rata-rata untuk menentukan tren harga, dan strategi pelacakan tren yang mengamati perubahan tingkat harga untuk mengimbangi pergerakan.
Prinsip Strategi
Strategi ini didasarkan pada indikator-indikator berikut:
Sudut rata-rata: Sudut yang lebih besar dari 0 adalah tren naik, dan lebih kecil dari 0 adalah tren turun, dengan menghitung sudut kemiringan dari garis rata-rata Jurik dan rata-rata bergerak indeks.
Rasio perubahan harga: menghitung perubahan harga penutupan 12 garis K terbaru, dengan volatilitas untuk memfilter sinyal yang tidak efektif.
Bila sudut garis rata ke atas (<=0) dan tingkat perubahan harga memenuhi syarat, lakukan lebih banyak; bila sudut garis rata ke bawah (<=0) dan tingkat perubahan harga memenuhi syarat, lakukan kosong.
Secara khusus, strategi ini pertama-tama menghitung sudut kemiringan garis rata-rata Jurik dan EMA. Kemudian menghitung indikator tingkat perubahan harga untuk digunakan selama periode penyaringan. Sinyal perdagangan dihasilkan ketika sudut rata-rata menunjukkan tren dan tingkat perubahan harga memenuhi syarat.
Analisis Keunggulan
Strategi ini memiliki keuntungan sebagai berikut:
Perhitungan tren dengan menggunakan garis rata-rata sangat dapat diandalkan, dan memiliki tingkat kemenangan yang tinggi.
Indikator tingkat perubahan harga dapat memfilter fluktuasi secara efektif untuk menghindari transaksi yang tidak efektif.
Jurik, yang memberikan respons cepat terhadap terobosan, dan EMA, yang memberikan penilaian tren yang stabil, saling melengkapi.
Menggunakan metode perdagangan jangka pendek dan dua arah, Anda dapat menangkap mata uang yang lebih menguntungkan dalam situasi yang sedang tren.
Analisis risiko
Strategi ini juga memiliki beberapa risiko:
Pada saat harga bergejolak, rata-rata garis menghasilkan sinyal yang salah. Risiko ini dapat dikurangi dengan parameter optimasi.
Sinyal linear yang masuk ke setup mungkin sering bergeser, menghasilkan terlalu banyak transaksi yang tidak perlu. Kondisi penyaringan tambahan dapat ditambahkan untuk mengurangi transaksi yang tidak valid.
Stop loss dapat ditembus jika terjadi insiden yang menyebabkan harga melonjak tinggi, dan stop loss dapat dilepas dengan tepat.
Arah optimasi
Strategi ini dapat dioptimalkan dalam beberapa hal:
Mengoptimalkan parameter rata-rata, mencari kombinasi parameter terbaik, meningkatkan stabilitas strategi.
Meningkatkan kondisi penyaringan seperti volatilitas, volume transaksi, dan lebih lanjut mengurangi transaksi yang tidak valid.
Hal ini dikombinasikan dengan indikator-indikator lain untuk menentukan titik-titik stop loss, sehingga stop loss menjadi lebih cerdas.
Mengembangkan algoritma yang dapat disesuaikan dengan ukuran transaksi untuk menghasilkan keuntungan yang lebih merata.
Meringkaskan
Strategi ini secara keseluruhan merupakan strategi pelacakan tren yang sangat praktis. Strategi ini sangat dapat diandalkan untuk menilai tren menggunakan kemiringan rata-rata, dan indikator tingkat perubahan harga dapat secara efektif menyaring sinyal yang tidak efektif.
/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Based on ma angles code by Duyck which also uses Everget Jurik MA calulation and angle calculation by KyJ
strategy("Trend Angle BF", overlay=false)
/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
src=input(ohlc4,title="source")
// definition of "Jurik Moving Average", by Everget
jma(_src,_length,_phase,_power) =>
phaseRatio = _phase < -100 ? 0.5 : _phase > 100 ? 2.5 : _phase / 100 + 1.5
beta = 0.45 * (_length - 1) / (0.45 * (_length - 1) + 2)
alpha = pow(beta, _power)
jma = 0.0
e0 = 0.0
e0 := (1 - alpha) * _src + alpha * nz(e0[1])
e1 = 0.0
e1 := (_src - e0) * (1 - beta) + beta * nz(e1[1])
e2 = 0.0
e2 := (e0 + phaseRatio * e1 - nz(jma[1])) * pow(1 - alpha, 2) + pow(alpha, 2) * nz(e2[1])
jma := e2 + nz(jma[1])
//// //// Determine Angle by KyJ //// ////
angle(_src) =>
rad2degree=180/3.14159265359 //pi
ang=rad2degree*atan((_src[0] - _src[1])/atr(14))
jma_line=jma(src,10,50,1)
ma=ema(src,input(56))
jma_slope=angle(jma_line)
ma_slope=angle(ma)
///////////// Rate Of Change /////////////
source = close
roclength = input(12, minval=1)
pcntChange = input(2, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = ma_slope>=0 and isMoving()
short = ma_slope<=0 and isMoving()
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(2.0, title='Stop Loss %') / 100
tp_inp = input(900.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
///////////// Plotting /////////////
hline(0, title='Zero line', color=color.purple, linewidth=1)
plot(ma_slope,title="ma slope", linewidth=2,color=ma_slope>=0?color.lime:color.red)
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)