Strategi penjejakan arah aliran berdasarkan purata bergerak kuantitatif
ChaoZhang
Gambaran keseluruhan
Strategi ini dilakukan dengan mengira dua purata bergerak berdasarkan jumlah dagangan, dan menilai arah trend semasa berdasarkan arah perbezaan mereka, kemudian melakukan posisi panjang atau posisi pendek. Strategi ini mudah digunakan dan dapat mengesan trend pasaran dengan berkesan.
Prinsip Strategi
Hitung garis pantas dan garis perlahan. Garis pantas adalah purata bergerak kuantitatif berdasarkan kitaran garis pantas yang ditakrifkan oleh pengguna, dan garis perlahan adalah purata bergerak kuantitatif berdasarkan kitaran garis perlahan.
Hitung perbezaan antara dua garis. Garis laju dikurangkan dari garis perlahan untuk mendapatkan kurva perbezaan.
Menentukan arah trend. Apabila garis cepat melintasi garis lambat, buat lebih; apabila garis cepat melintasi garis lambat, buat lebih.
Isikan isyarat dagangan. Isikan isyarat berganda apabila harga naik; isikan isyarat kosong apabila harga turun.
Tetapkan stop loss. Tetapkan kedudukan stop loss dengan peratusan stop loss tetap yang ditentukan oleh pengguna atau stop loss dinamik berdasarkan ATR.
Keadaan Keluar Dari Pertaruhan: Apabila anda memegang kedudukan, anda akan keluar dari Pertaruhan jika anda mencetuskan Hentikan Kerosakan atau tanda-tanda pembalikan.
Analisis kelebihan
Menggunakan petunjuk kuantitatif untuk mengenal pasti trend, tidak mudah disesatkan oleh terobosan palsu.
Garis perlahan dan pantas untuk menapis bunyi pasaran dan mengelakkan dagangan yang kerap.
Tetapan Stop Loss berkesan mengawal risiko kerugian.
Strategi logiknya mudah difahami dan mudah dilaksanakan.
Parameter boleh disesuaikan untuk memenuhi keperluan pelbagai jenis dan tempoh masa.
Analisis risiko
Tetapan parameter yang tidak betul boleh menyebabkan frekuensi dagangan yang terlalu tinggi atau kehilangan trend.
Hentian tetap mungkin terlalu mekanikal dan tidak dapat menyesuaikan diri dengan perubahan pasaran.
Perubahan dalam hubungan kuantiti-harga mungkin mempengaruhi kesan indikator kuantitatif.
Risiko 1 boleh mencari kombinasi terbaik melalui parameter pengoptimuman
Risiko 2 boleh menggunakan hentian ATR dinamik sebagai pengganti hentian tetap.
Risiko 3 memerlukan perhatian terhadap kesan perubahan jumlah jualan terhadap strategi.
Arah pengoptimuman
Uji kombinasi parameter yang berbeza antara garis pantas dan perlahan.
Cubalah dengan penunjuk harga lain, seperti OBV, William dan lain-lain.
Peningkatan Stop Loss Berasaskan Fluktuasi
Penilaian kesannya dalam kombinasi dengan penunjuk lain.
Penilaian kesan dalam pelbagai jenis transaksi.
ringkaskan
Strategi ini menjejaki trend melalui kombinasi garis laju dan perlahan dengan garis purata kuantitatif, logik perdagangan mudah dan jelas, parameter boleh disesuaikan dengan optimum. Tetapan stop loss membantu mengawal risiko. Kesan penggunaan kombinasi indikator lain dapat dinilai seterusnya.
/*backtest
start: 2023-08-18 00:00:00
end: 2023-09-17 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("EVWMA 6HR", overlay=false, precision=2, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
// Credit to QuantNomad for the main idea behind this code
/////////////// Time Frame ///////////////
_1 = input(false, "════════ Test Period ═══════")
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
///////////// EVWMA /////////////
_2 = input(false, "════════ EVMA ═══════")
fast_sum_length = input(5, title = "Fast Sum Length", type = input.integer)
slow_sum_length = input(11, title = "Slow Sum Length", type = input.integer)
fast_vol_period = sum(volume, fast_sum_length)
slow_vol_period = sum(volume, slow_sum_length)
fast_evwma = 0.0
fast_evwma := ((fast_vol_period - volume) * nz(fast_evwma[1], close) + volume * close) / (fast_vol_period)
slow_evwma = 0.0
slow_evwma := ((slow_vol_period - volume) * nz(slow_evwma[1], close) + volume * close) / (slow_vol_period)
diff = fast_evwma - slow_evwma
/////////////// Strategy ///////////////
long = fast_evwma > slow_evwma
short = fast_evwma < slow_evwma
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])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
SL_type = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inp = input(9.0, title='Fixed Stop Loss %') / 100
atrLkb = input(20, minval=1, title='ATR Stop Period')
atrMult = input(1.5, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop1 = 0.0
longStop1 := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop1[1]
shortStop1 = 0.0
shortStop1 := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop1[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
_5 = input(false, "══════ Longs or Shorts ═════")
useLongs = input(true, title="Use Longs")
useShorts = input(true, title="Use Shorts")
/////////////// Execution ///////////////
if testPeriod()
if useLongs
strategy.entry("L", strategy.long, when=long)
strategy.exit("L SL", "L", stop = SL_type == "Fixed" ? long_sl : longStop1, when=since_longEntry > -1)
if useShorts
strategy.exit("S SL", "S", stop = SL_type == "Fixed" ? short_sl : shortStop1, when=since_shortEntry > -1)
strategy.entry("S", strategy.short, when=short)
if not useShorts
strategy.close("L", when=short)
if not useLongs
strategy.close("S", when=long)
/////////////// Plotting ///////////////
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
p1 = plot(diff, title = "Delta", color = long ? color.lime : short ? color.red : na, transp=0)
p2 = plot(0, color = color.white)
fill(p1, p2, color = long ? color.lime : short ? color.red : na, transp=60)