Strategi ini mengira dua purata bergerak berwajaran volum sebagai garis cepat dan perlahan. Ia menentukan arah trend berdasarkan perbezaan antara kedua-dua garis dan mengambil kedudukan panjang atau pendek dengan sewajarnya. Strategi ini mudah dan berkesan dalam mengesan trend pasaran.
Mengira garis pantas dan perlahan menggunakan purata bergerak berwajaran volum berdasarkan tempoh pantas dan perlahan yang ditakrifkan oleh pengguna.
Hitung perbezaan antara garis cepat dan perlahan.
Tentukan arah trend. Perpindahan garis pantas di atas garis perlahan menunjukkan trend menaik dan perpindahan di bawah menunjukkan trend menurun.
Isikan isyarat panjang/pendek. Pergi panjang apabila garisan pantas melintasi garis perlahan. Pergi pendek apabila garisan pantas melintasi garis perlahan.
Tetapkan stop loss berdasarkan peratusan tetap atau ATR dinamik yang ditakrifkan oleh pengguna.
Peraturan keluar: tutup kedudukan jika stop loss dipukul atau isyarat mundur berlaku.
Menggunakan penunjuk kuantitatif untuk mengenal pasti trend dan mengelakkan pecah palsu.
Gabungan talian pantas dan perlahan menapis bunyi pasaran dan mengelakkan overtrading.
Stop loss berkesan mengawal risiko penurunan.
Logik yang mudah dan mudah difahami.
Parameter yang boleh disesuaikan untuk produk dan jangka masa yang berbeza.
Tetapan parameter yang tidak betul boleh menyebabkan overtrading atau trend yang terlepas.
Stop loss tetap mungkin terlalu kaku untuk keadaan pasaran yang berubah.
Perubahan dalam hubungan jumlah dan harga boleh memberi kesan kepada keberkesanan.
Risiko 1 boleh dikurangkan melalui optimalisasi parameter.
Risiko 2 boleh ditangani melalui kehilangan berhenti ATR dinamik.
Risiko 3 perlu memantau perubahan jumlah.
Uji kombinasi parameter garis pantas dan perlahan yang berbeza.
Cuba penunjuk harga jumlah lain seperti OBV, William
Tambah penangguhan berasaskan turun naik.
Menilai gabungan dengan penunjuk lain.
Uji keberkesanan di pelbagai instrumen dagangan.
Strategi ini menggunakan purata bergerak cepat dan perlahan untuk mengesan trend dengan logik yang mudah. Parameter boleh dioptimumkan dan menghentikan kawalan risiko. Penilaian lanjut mengenai menggabungkan penunjuk boleh meningkatkan keberkesanan.
/*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)