1. वर्ग
  2. प्रवृत्ति कोण चलती औसत क्रॉसओवर रणनीति

प्रवृत्ति कोण चलती औसत क्रॉसओवर रणनीति

लेखक:चाओझांग, दिनांकः 2024-01-25 14:35:13
टैगः

img

अवलोकन

रणनीति तर्क

रणनीति मुख्य रूप से निम्नलिखित आंकलन संकेतकों पर आधारित हैः

  1. मूविंग एवरेज ढलान कोणः मूल्य प्रवृत्ति दिशा निर्धारित करने के लिए ज्यूरिक मूविंग एवरेज और घातीय मूविंग एवरेज के ढलान कोणों की गणना करें। 0 से अधिक कोण अपट्रेंड का संकेत देता है, 0 से कम का अर्थ है डाउनट्रेंड।

  2. मूल्य परिवर्तन दरः अस्थिरता द्वारा संकेतों को फ़िल्टर करने के लिए पिछले 12 बार में समापन मूल्य में परिवर्तन की दर की गणना करें।

जब चलती औसत ढलान ऊपर जाती है (० से अधिक) और मूल्य परिवर्तन दर मानदंडों को पूरा करती है, तो लंबी जाती है। जब ढलान नीचे जाती है (० से कम) और मूल्य परिवर्तन दर मानदंडों को पूरा करती है, तो छोटी जाती है।

विशेष रूप से, रणनीति पहले ज्यूरिक एमए और ईएमए के ढलान कोणों की गणना करती है। फिर मूल्य परिवर्तन दर संकेतक को रेंज-बाउंड अवधि को फ़िल्टर करने के लिए गणना की जाती है। जब दोनों चलती औसत ढलान संकेत प्रवृत्ति और मूल्य परिवर्तन दर मानदंडों को पूरा करते हैं, तो ट्रेडिंग संकेत उत्पन्न होता है।

लाभ विश्लेषण

इस रणनीति के फायदे:

  1. प्रवृत्ति को निर्धारित करने के लिए एमए ढलान का उपयोग करना अच्छी जीत दर के साथ बहुत विश्वसनीय है।

  2. मूल्य परिवर्तन दर सूचक अमान्य ट्रेडों से बचने के लिए प्रभावी रूप से उतार-चढ़ाव को फ़िल्टर करता है।

  3. ज्यूरिक एमए ब्रेकआउट पर त्वरित प्रतिक्रिया देता है जबकि ईएमए स्थिर रुझान का न्याय प्रदान करता है, दोनों पूरक हैं।

  4. ट्रेंडिंग मार्केट में लंबी और छोटी दोनों जगह जाकर अधिक मुनाफा कमाया जा सकता है।

जोखिम विश्लेषण

इस रणनीति के कुछ जोखिमः

  1. चरम मूल्य विप्सॉ में, एमए गलत संकेत उत्पन्न कर सकता है। यह पैरामीटर अनुकूलन द्वारा कम किया जा सकता है।

  2. सिग्नल अक्सर रेंजिंग के दौरान अनावश्यक ट्रेडों का कारण बन सकते हैं। अतिरिक्त फ़िल्टर जोड़ा जा सकता है।

  3. स्टॉप लॉस को अचानक मूल्य अंतर घटनाओं में तोड़ा जा सकता है। व्यापक स्टॉप लॉस का उपयोग किया जा सकता है।

अनुकूलन दिशाएँ

इस रणनीति को निम्नलिखित पहलुओं में अनुकूलित किया जा सकता हैः

  1. स्थिरता में सुधार के लिए सर्वोत्तम पैरामीटर संयोजन खोजने के लिए एमए मापदंडों का अनुकूलन करें।

  2. अमान्य ट्रेडों को और कम करने के लिए अस्थिरता, वॉल्यूम फ़िल्टर आदि जोड़ें।

  3. स्मार्ट स्टॉप लॉस पोजिशनिंग के लिए अन्य संकेतक शामिल करें।

  4. स्थिर लाभप्रदता के लिए अनुकूलन योग्य स्थिति आकार एल्गोरिदम विकसित करें।

निष्कर्ष

कुल मिलाकर यह एक बहुत ही व्यावहारिक ट्रेंड फॉलोअप रणनीति है। यह एमए ढलान कोण का उपयोग करके ट्रेंड को विश्वसनीय रूप से निर्धारित करता है, और प्रभावी रूप से मूल्य परिवर्तन दर संकेतक का उपयोग करके शोर संकेतों को फ़िल्टर करता है। लंबी और छोटी दोनों स्थिति लेना अच्छा लाभ कमा सकता है। निरंतर अनुकूलन के साथ, यह रणनीति एक बहुत ही स्थिर और विश्वसनीय मात्रात्मक रणनीति बन सकती है।

/*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)
अधिक

2019 FMZ - सभी अधिकार सुरक्षित