मोमेंटम ब्रिक रणनीति


निर्माण तिथि: 2024-02-19 15:32:17 अंत में संशोधित करें: 2024-02-19 15:32:17
कॉपी: 1 क्लिक्स: 577
1
ध्यान केंद्रित करना
1617
समर्थक

मोमेंटम ब्रिक रणनीति

यह रणनीति बाजार की गतिशीलता में परिवर्तन को आकलन करने के लिए एक झंझरी के गठन का अनुकरण करती है, जो झंझरी की दिशा के अनुसार अधिक खाली करती है।

रणनीति सिद्धांत

इस रणनीति का मूल सिद्धांत एटीआर और समापन मूल्य के संबंध की गणना करके एक ईंट के गठन का अनुकरण करना है। विशेष रूप से, दो चर Brick1 और Brick2 को परिभाषित करना।

Brick1 की गणना इस प्रकार की जाती हैः यदि समापन मूल्य Brick1 के कल के मूल्य + ATR से अधिक है, तो Brick1 Brick1 का कल का मूल्य + ATR है; यदि समापन मूल्य Brick1 के कल के मूल्य - ATR से कम है, तो Brick1 Brick1 का कल का मूल्य - ATR है; अन्यथा Brick1 Brick1 का कल का मूल्य प्राप्त करता है।

Brick2 की गणना इस प्रकार की जाती हैः यदि Brick1 का मूल्य Brick1 के कल के मूल्य के बराबर नहीं है, तो Brick2 Brick1 का कल का मूल्य है; अन्यथा, Brick2 कल का मूल्य है।

इस प्रकार, एक खंभे के निर्माण का अनुकरण किया जाता है। जब Brick1 ऊपर जाता है और एक ATR से अधिक होता है, तो एक ऊपरी खंभे का निर्माण होता है; जब Brick1 नीचे जाता है और एक ATR से अधिक होता है, तो एक नीचे की खंभे का निर्माण होता है। Brick2 एक खंभे की स्थिति को रिकॉर्ड करता है।

जब Brick1 और Brick2 ऊपर की ओर से पार करते हैं, तो यह दर्शाता है कि खंभा ऊपर की ओर विस्तारित है, और इसे बहुमुखी माना जाता है; जब Brick1 और Brick2 नीचे की ओर से पार करते हैं, तो यह दर्शाता है कि खंभा नीचे की ओर सिकुड़ता है, और इसे खाली माना जाता है।

रणनीतिक लाभ

  1. एटीआर का उपयोग कर पंखों के गठन का आकलन करें, एक निश्चित आकार के पंखों का उपयोग करने से बचें और बाजार में उतार-चढ़ाव के लिए गतिशील रूप से अनुकूलित करें
  2. पंखों के क्रॉसिंग के माध्यम से पॉलीवॉलिक दिशा का आकलन करें, गतिशीलता में परिवर्तन की पहचान करें
  3. विभिन्न एटीआर चक्रों के माध्यम से बाजार की गतिशीलता के लिए निर्णय की संवेदनशीलता को समायोजित किया जा सकता है
  4. विज़ुअलाइज़ेशन और क्रॉसिंग की स्थिति, बाजार के रुझानों को समझने के लिए

रणनीतिक जोखिम

  1. यदि एटीआर आकार का चयन रणनीति की लाभप्रदता को प्रभावित करता है। यदि एटीआर बहुत छोटा है, तो बहुत अधिक स्टीम बनता है, अधिक अमान्य संकेत उत्पन्न करता है; यदि एटीआर बहुत बड़ा है, तो बहुत कम स्टीम, अवसरों को याद करना आसान है।
  2. वास्तविक रुझानों में शायद ही कभी मोमबत्तियों का अनुसरण किया गया हो, और मोमबत्तियों के क्रॉसिंग सिग्नल को बाजार के पलटाव से खारिज कर दिया जा सकता है।
  3. लेनदेन की लागत के प्रति बहुत संवेदनशील होना आवश्यक है, अन्यथा क्रॉसओवर के साथ बार-बार लेनदेन से शुद्ध आय में भारी कमी आएगी।

पैरामीटर अनुकूलन के माध्यम से इष्टतम एटीआर चक्र का पता लगाया जा सकता है; निष्क्रिय संकेतों से होने वाले नुकसान को कम करने के लिए स्टॉप-स्टॉप-लॉस रणनीति को समायोजित करें; लागत के लाभ पर प्रभाव को कम करने के लिए ट्रेडिंग किस्मों को उचित रूप से बढ़ाएं।

रणनीति अनुकूलन

  1. सिग्नल फ़िल्टरिंग को अन्य संकेतकों के साथ संयोजन में किया जा सकता है, जैसे कि क्वांटम ऊर्जा सूचक, कंपन सूचक, आदि, निष्क्रिय सिग्नल से बचने के लिए
  2. प्रवृत्ति फ़िल्टर जोड़े गए, केवल प्रवृत्ति की दिशा में संकेत देते हैं, रिवर्स हानि से बचें
  3. परीक्षण अवधि के दौरान ऑप्टिमाइज़ेशन विधि का उपयोग करके ऑप्टिमाइज़ेशन विधि का स्वचालित रूप से पता लगाना

संक्षेप

यह रणनीति बाजार में अल्पकालिक रुझानों और गतिशीलता का आकलन करने के लिए गतिशील अनुकरण झंझरी का उपयोग करती है। रणनीति में अनुकूलन के लिए अधिक जगह है। पैरामीटर अनुकूलन और सिग्नल फ़िल्टरिंग से स्थिरता में और वृद्धि हो सकती है।

रणनीति स्रोत कोड
/*backtest
start: 2023-02-12 00:00:00
end: 2024-02-18 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4


///Component Code Start
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(01, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear, testStartMonth, testStartDay, 0, 0)

testStopYear = input(2025, "Backtest Stop Year")
testStopMonth = input(1, "Backtest Stop Month")
testStopDay = input(1, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear, testStopMonth, testStopDay, 0, 0)



/// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=input.bool, defval=false)
testPeriodBackgroundColor = testPeriodBackground and time >= testPeriodStart and time <= testPeriodStop ? 
   #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
/// Component Code Stop


//Zack_the_Lego (original AUTHOR) made into strategy by mkonsap
strategy("Flex Renko Emulator", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)
margin = input(true, title="Margin?")
Margin = margin ? margin : false
res = input(type=input.resolution, defval="D", title="Resolution of ATR")
xATR = atr(14)
//TF = x78tf ? "78" : "39"
BrickSize = security(syminfo.tickerid, res, xATR)

//Brick1 =  close >  nz(Brick1[1]) + BrickSize ? nz(Brick1[1]) + BrickSize : close <
                    //nz(Brick1[1]) - BrickSize ?
                        //nz(Brick1[1]) - BrickSize
                            //: nz(Brick1[1]))


Brick1() =>
    s1 = 0.0
    s1 := close > nz(s1[1]) + BrickSize ? nz(s1[1]) + BrickSize : 
       close < nz(s1[1]) - BrickSize ? nz(s1[1]) - BrickSize : nz(s1[1])
    s1


Brick2() =>
    s2 = 0.0
    Brick1_1 = Brick1()
    s2 := Brick1() != Brick1()[1] ? Brick1_1[1] : nz(s2[1])
    s2

colorer = Brick1() > Brick2() ? color.green : color.red
p1 = plot(Brick1(), color=colorer, linewidth=4, title="Renko")
p2 = plot(Brick2(), color=colorer, linewidth=4, title="Renko")
fill(p1, p2, color=color.purple, transp=50)




mylong = crossover(Brick1(), Brick2())
myshort = crossunder(Brick1(), Brick2())

last_long = float(na)
last_short = float(na)
last_long := mylong ? time : nz(last_long[1])
last_short := myshort ? time : nz(last_short[1])

in_long = last_long > last_short ? 2 : 0
in_short = last_short > last_long ? 2 : 0

mylong2 = crossover(Brick1(), Brick2())
myshort2 = crossunder(Brick1(), Brick2())

last_long2 = float(na)
last_short2 = float(na)
last_long2 := mylong2 ? time : nz(last_long2[1])
last_short2 := myshort2 ? time : nz(last_short2[1])

in_long2 = last_long2 > last_short2 ? 0 : 0
in_short2 = last_short2 > last_long2 ? 0 : 0


condlongx = in_long + in_long2
condlong = crossover(condlongx, 1.9)
condlongclose = crossunder(condlongx, 1.9)

condshortx = in_short + in_short2
condshort = crossover(condshortx, 1.9)
condshortclose = crossunder(condshortx, 1.9)


// === STRATEGY - LONG POSITION EXECUTION WITH CLOSE ORDERS ===
//enterLong() => crossover(condlongx, 1.9) and testPeriod() and strategy.position_size <= 0
//exitLong()  => crossunder(condlongx, 1.9) and testPeriod() and strategy.position_size > 0
//strategy.entry(id = "Long", long = true, when = enterLong())
//strategy.close(id = "Long", when = exitLong())
// === STRATEGY - SHORT POSITION EXECUTION WITH CLOSE ORDER===
//enterShort() => crossover(condshortx, 1.9) and testPeriod() and strategy.position_size >= 0 and Margin
//exitShort() => crossunder(condshortx, 1.9)  and testPeriod() and strategy.position_size < 0
//strategy.entry(id = "Short", long = false, when = enterShort())
//strategy.close(id = "Short", when = exitShort())   
//END


///STRATEGY ONLY LONG AND SHORT/////
if crossover(condlongx, 1.9) and testPeriod() and strategy.position_size <= 0
    strategy.entry("Long", strategy.long, comment="Long")

if crossover(condshortx, 1.9) and testPeriod() and strategy.position_size >= 0
    strategy.close("Long", when=not Margin)

if crossover(condshortx, 1.9) and testPeriod() and strategy.position_size >= 0
    strategy.entry("Short", strategy.short, comment="Short", when=Margin)

/////// END ////