Strategi ini menghitung dua rata-rata bergerak tertimbang volume sebagai garis cepat dan lambat. Ini menentukan arah tren berdasarkan perbedaan antara kedua garis dan mengambil posisi panjang atau pendek sesuai. Strategi ini sederhana dan efektif dalam melacak tren pasar.
Menghitung garis cepat dan lambat menggunakan rata-rata bergerak tertimbang volume berdasarkan periode cepat dan lambat yang ditentukan pengguna.
Hitung perbedaan antara garis cepat dan lambat.
Tentukan arah tren. Crossover dari garis cepat di atas garis lambat menunjukkan tren naik dan crossover di bawah menunjukkan tren turun.
Mengeluarkan sinyal panjang/pendek. Pergi panjang ketika garis cepat melintasi garis lambat. Pergi pendek ketika garis cepat melintasi garis lambat.
Atur stop loss berdasarkan persentase tetap atau ATR dinamis yang ditentukan pengguna.
Aturan keluar. tutup posisi jika stop loss terpukul atau sinyal mundur terjadi.
Menggunakan indikator kuantitatif untuk mengidentifikasi tren dan menghindari pecah palsu.
Kombinasi jalur cepat dan lambat menyaring kebisingan pasar dan menghindari overtrading.
Stop loss secara efektif mengendalikan risiko penurunan.
Logika yang sederhana dan mudah dimengerti.
Parameter yang dapat disesuaikan untuk produk dan jangka waktu yang berbeda.
Pengaturan parameter yang tidak benar dapat menyebabkan overtrading atau trend yang terlewatkan.
Stop loss tetap mungkin terlalu kaku untuk perubahan kondisi pasar.
Perubahan hubungan volume dan harga dapat mempengaruhi efektivitas.
Risiko 1 dapat dikurangi melalui optimasi parameter.
Risiko 2 dapat ditangani melalui stop loss ATR dinamis.
Risiko 3 perlu pemantauan perubahan volume.
Uji kombinasi parameter garis cepat dan lambat yang berbeda.
Cobalah indikator harga volume lainnya seperti OBV, William
Tambahkan volatilitas berbasis berhenti.
Evaluasi kombinasi dengan indikator lain.
Uji efektivitas di berbagai instrumen perdagangan.
Strategi ini menggunakan rata-rata bergerak cepat dan lambat untuk melacak tren dengan logika sederhana. Parameter dapat dioptimalkan dan menghentikan risiko kontrol. Evaluasi lebih lanjut tentang menggabungkan indikator dapat meningkatkan efektivitas.
/*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)