यह रणनीति दो वॉल्यूम वेटेड मूविंग एवरेज को फास्ट और स्लो लाइन के रूप में गणना करती है। यह दो लाइनों के बीच अंतर के आधार पर प्रवृत्ति की दिशा निर्धारित करती है और तदनुसार लंबी या छोटी स्थिति लेती है। यह रणनीति बाजार के रुझानों को ट्रैक करने में सरल और प्रभावी है।
उपयोगकर्ता द्वारा परिभाषित तेज और धीमी अवधि के आधार पर वॉल्यूम भारित चलती औसत का उपयोग करके तेज और धीमी रेखाओं की गणना करें।
तेज और धीमी रेखाओं के बीच अंतर की गणना करें।
प्रवृत्ति की दिशा निर्धारित करें. धीमी रेखा के ऊपर तेज रेखा का क्रॉसओवर ऊपर की प्रवृत्ति को दर्शाता है और नीचे का क्रॉसओवर नीचे की प्रवृत्ति को दर्शाता है.
लंबे/छोटे संकेत जारी करें. जब तेज रेखा धीमी रेखा के ऊपर से गुजरती है तो लंबा करें. जब तेज रेखा धीमी रेखा के नीचे से गुजरती है तो छोटा करें.
उपयोगकर्ता द्वारा परिभाषित निश्चित प्रतिशत या गतिशील एटीआर के आधार पर स्टॉप लॉस सेट करें।
बाहर निकलने के नियम. यदि स्टॉप लॉस मारा जाता है या रिवर्स सिग्नल होता है तो बंद स्थिति।
प्रवृत्तियों की पहचान करने और झूठे ब्रेकआउट से बचने के लिए मात्रात्मक संकेतक का उपयोग करता है।
तेज और धीमी लाइन का संयोजन बाजार के शोर को फ़िल्टर करता है और ओवरट्रेडिंग से बचाता है।
स्टॉप लॉस प्रभावी रूप से डाउनसाइड जोखिम को नियंत्रित करता है।
सरल और समझने में आसान तर्क।
विभिन्न उत्पादों और समय सीमाओं के लिए अनुकूलन योग्य पैरामीटर।
अनुचित पैरामीटर सेटिंग से ओवरट्रेडिंग या मिस किए गए रुझान हो सकते हैं।
फिक्स्ड स्टॉप लॉस बाजार की बदलती परिस्थितियों के लिए बहुत कठोर हो सकता है।
मात्रा और मूल्य संबंधों में परिवर्तन प्रभावशीलता को प्रभावित कर सकते हैं।
जोखिम 1 को पैरामीटर अनुकूलन के माध्यम से कम किया जा सकता है।
जोखिम 2 को गतिशील एटीआर स्टॉप लॉस के माध्यम से संबोधित किया जा सकता है।
जोखिम 3 को वॉल्यूम परिवर्तनों की निगरानी करने की आवश्यकता है।
विभिन्न तेज और धीमी लाइन पैरामीटर संयोजनों का परीक्षण करें।
OBV, William
अस्थिरता आधारित स्टॉप जोड़ें।
अन्य संकेतकों के साथ संयोजन का मूल्यांकन करें।
विभिन्न व्यापारिक साधनों में प्रभावशीलता का परीक्षण करें।
यह रणनीति सरल तर्क के साथ रुझानों को ट्रैक करने के लिए तेज़ और धीमी मात्रा में चलती औसत का उपयोग करती है। मापदंडों को अनुकूलित किया जा सकता है और जोखिम को नियंत्रित करना बंद कर सकता है। संकेतकों के संयोजन पर आगे के मूल्यांकन से प्रभावशीलता में सुधार हो सकता है।
/*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)