मूविंग एवरेज डबल-क्लिक गोल्डन क्रॉस निरंतर वृद्धि रणनीति


निर्माण तिथि: 2023-11-13 10:47:48 अंत में संशोधित करें: 2023-11-13 10:47:48
कॉपी: 0 क्लिक्स: 649
1
ध्यान केंद्रित करना
1617
समर्थक

मूविंग एवरेज डबल-क्लिक गोल्डन क्रॉस निरंतर वृद्धि रणनीति

अवलोकन

यह एक ट्रेडिंग रणनीति है जो चलती औसत के रूप का उपयोग करती है, जो ट्रेंड लाइन के साथ लगातार ऊपर की ओर होती है। जब तेज लाइन धीमी रेखा को नीचे से तोड़ती है, तो गोल्ड फोर्क सिग्नल बनता है। यदि गोल्ड फोर्क के बाद की प्रवृत्ति ऊपर की ओर जारी रहती है, तो इस चरण में अधिक स्थिति खोला जा सकता है। जब कीमत स्टॉप-लॉस लाइन या स्टॉप-लॉस लाइन तक पहुंचती है, तो स्टॉप-लॉस या स्टॉप-लॉस चुन सकते हैं।

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

यह रणनीति मुख्य रूप से चलती औसत के गोल्डफ़ॉक्स फॉर्मेट के आधार पर प्रवेश के समय को निर्धारित करती है। विशेष रूप से, एक तेजी से चलती औसत MA1 और एक धीमी गति से चलती औसत MA2 को परिभाषित करना। जब MA1 नीचे की ओर से MA2 को तोड़ता है, तो यह अधिक संकेत देता है।

शॉर्ट-ट्रेन्ड गोल्डफोर्क के कारण होने वाले झूठे संकेतों से बचने के लिए, रणनीति में एंगल थ्रॉल्ड निर्णय शामिल किया गया है, जो केवल एक खरीद संकेत को ट्रिगर करता है जब एमए 2 का कोण सेट थ्रॉल्ड से बड़ा होता है। यह कुछ गैर-प्रवृत्तिपूर्ण अल्पकालिक वृद्धि को फ़िल्टर कर सकता है।

रणनीति एक ही समय में एक स्टॉप-लॉस और एक स्टॉप-स्टॉप लाइन सेट करती है। स्टॉप-लॉस का उपयोग बाजार में अचानक होने वाले नुकसान से बचने के लिए किया जाता है, और स्टॉप-स्टॉप का उपयोग लाभप्रद प्रस्थान को लॉक करने के लिए किया जाता है। यह विशेष रूप से प्रवेश मूल्य की एक निश्चित प्रतिशत सीमा के रूप में सेट किया गया है।

जब कीमतों में बढ़ोतरी रुकने के बिंदु तक पहुंचती है, तो रणनीति रुकने और बाहर निकलने का विकल्प चुनती है। साथ ही, यदि इस दौर में बढ़ोतरी मजबूत है, तो रणनीति फिर से शून्य रिवर्स ऑपरेशन करती है।

श्रेष्ठता विश्लेषण

यह एक अपेक्षाकृत सरल और सहज ट्रेंड ट्रैकिंग रणनीति है। इसके कुछ फायदे हैंः

  1. चलती औसत संयोजन का उपयोग करके बाजार के शोर को फ़िल्टर करें और प्रवृत्ति की दिशा को लॉक करें
  2. कोण थ्रेशोल्ड अल्पकालिक झटके से बचने में मदद करता है
  3. दोतरफा ऑपरेशन, जो अस्थिरता में लाभदायक है
  4. स्टॉप लॉस स्टॉप सेट करें, जोखिम को नियंत्रित करें

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

इस रणनीति के कुछ जोखिम भी हैं, जिनके बारे में ध्यान देने की आवश्यकता हैः

  1. चलती औसत में देरी के कारण, कीमतों में बदलाव की संभावना नहीं
  2. स्टॉप लॉस के बावजूद, पल-पल के बाजार में स्टॉप लॉस के टूटने की संभावना मौजूद है
  3. द्विपक्षीय लेनदेन में जोखिम दोगुना हो गया है, गलत चयन से नुकसान हो सकता है
  4. अनुचित पैरामीटर सेट, जैसे कि चलती औसत आवृत्ति का चयन, जो रणनीति के प्रदर्शन को प्रभावित कर सकता है

अनुकूलन दिशा

इस रणनीति को और अधिक अनुकूलित करने के लिए निम्नलिखित कदम उठाए जा सकते हैं:

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

संक्षेप

कुल मिलाकर, यह एक सरल और व्यावहारिक प्रवृत्ति ट्रैकिंग रणनीति है। इसके कुछ फायदे हैं, लेकिन जोखिमों के बारे में भी ध्यान देने की आवश्यकता है। बेहतर स्थिर रिटर्न प्राप्त करने के लिए और अधिक पैरामीटर अनुकूलन, संकेतक अनुकूलन, स्टॉप-लॉस स्टॉप सेटिंग आदि के माध्यम से सुधार किया जा सकता है। लेकिन कोई भी रणनीति पूरी तरह से बाजार के प्रणालीगत जोखिम से बच नहीं सकती है।

रणनीति स्रोत कोड
/*backtest
start: 2023-11-05 00:00:00
end: 2023-11-12 00:00:00
period: 15m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//written by [email protected]
//@version=5
strategy(title="MJ-Dual Moving Average",initial_capital=10000,overlay=false)

// import TradingView/ZigZag/6 as ZigZagLib 

// // Create Zig Zag instance from user settings.
// var zigZag = ZigZagLib.newInstance(
//   ZigZagLib.Settings.new(
//       input.float(5.0, "Price deviation for reversals (%)", 0.00001, 100.0, 0.5, "0.00001 - 100"),
//       input.int(10, "Pivot legs", 2),
//       input(#2962FF, "Line color"),
//       input(true, "Extend to last bar"),
//       input(true, "Display reversal price"),
//       input(true, "Display cumulative volume"),
//       input(true, "Display reversal price change", inline = "priceRev"),
//       input.string("Absolute", "", ["Absolute", "Percent"], inline = "priceRev"),
//       true)
//  )

// // Update 'zigZag' object on each bar with new ​pivots, ​volume, lines, labels.
// zigZag.update()
// // plot(zigZag.pivots, "zigZag")

ma1= ta.sma(close,8)
ma2= ta.sma(close,21)

angleCriteria = input.int(title="Angle", defval=7, minval=1, maxval=13)

i_lookback   = input.int(2,     "Angle Period", minval = 1)
i_atrPeriod  = input.int(10,    "ATR Period",   minval = 1)
i_angleLevel = input.int(6,     "Angle Level",  minval = 1)
i_maSource   = input.source(close, "MA Source")
TP = input.float(1, "TP", minval = 0.1)
SL = input.float(1, "SL", minval = 0.1)

f_angle(_src, _lookback, _atrPeriod) =>
    rad2degree = 180 / 3.141592653589793238462643  //pi 
    ang = rad2degree * math.atan((_src[0] - _src[_lookback]) / ta.atr(_atrPeriod)/_lookback)
    ang
_angle = f_angle(ma2, i_lookback, i_atrPeriod)
plot(ta.atr(i_atrPeriod), "atr")
// plot(ma1,color=#FF0000)
// plot(ma2,color=#00FF00)

crosso=ta.crossover(ma1,ma2) 
crossu=ta.crossunder(ma1,ma2)

_lookback = 15

f_somethingHappened(_cond, _lookback) =>
    bool _crossed = false
    for i = 1 to _lookback
        if _cond[i]
            _crossed := true
    _crossed
    
longcrossed = f_somethingHappened(crosso,_lookback)
shortcrossed = f_somethingHappened(crossu,_lookback)

atr_factor = 1
atr = ta.atr(i_atrPeriod)
e = atr * atr_factor 

afr = close 
afr := nz(afr[1], afr)

atr_factoryHigh = close + e
atr_factoryLow = close - e 

if atr_factoryLow > afr 
    afr := atr_factoryLow
if atr_factoryHigh < afr 
    afr := atr_factoryHigh

// plot(afr, "afr", display = display.data_window)
// plot(atr_factoryHigh, "afr", color = color.yellow, display = display.all)
// plot(atr_factoryLow, "afr", color = color.green, display = display.all)


inLong() => strategy.position_size > 0
inShort() => strategy.position_size < 0
inZero() => not inLong() and not inShort()

long = longcrossed and _angle > angleCriteria
short= shortcrossed and _angle < -(angleCriteria)

plotshape(long, "Buy", shape.arrowup, location.belowbar, color = #FF0000)
plotshape(short, "Sell", shape.arrowdown, location.abovebar, color = #00FF00)

var longTp = 0.0
var longSl = 0.0
var shortTp = 0.0
var shortSl = 0.0
[b_middle, b_high, b_low] = ta.bb(close, 20, 2)
entry_price = strategy.opentrades.entry_price(0)

if inZero()
    if short
        longTp := close * (1 + TP/100)
        longSl := close * (1 - SL/100)
        strategy.entry("LONG",strategy.long, comment = "tp:" + str.tostring(longTp) + " sl:" + str.tostring(longSl))
    if long
        shortTp := close * (1 - TP/100)
        shortSl := close * (1 + SL/100)
        strategy.entry("SHORT",strategy.short, comment = "tp:" + str.tostring(shortTp) + " sl:" + str.tostring(shortSl))

if inLong()
    // if close - entry_price > close * 0.005
    //     longSl := entry_price + close * 0.001
    if high > longTp
        strategy.close("LONG")
        if (close - open) > close * 0.014
            shortTp := close * (1 - TP/100)
            shortSl := close * (1 + SL/100)
            strategy.entry("SHORT",strategy.short, comment = "tp:" + str.tostring(shortTp) + " sl:" + str.tostring(shortSl))

    if close < longSl
        strategy.close("LONG")
    if open >= b_high and close >= b_high
        strategy.close("LONG")
    // if high > b_high and entry_price < high
    //     strategy.close("LONG")


if inShort()
    // if entry_price - close > close * 0.005
    //     shortSl := entry_price - close * 0.001
    if low < shortTp
        strategy.close("SHORT")
        if (open - close) > close * 0.014
            longTp := close * (1 + TP/100)
            longSl := close * (1 - SL/100)
            strategy.entry("LONG",strategy.long, comment = "tp:" + str.tostring(longTp) + " sl:" + str.tostring(longSl))


    if close > shortSl
        strategy.close("SHORT")
    if open < b_low and close < b_low
        strategy.close("SHORT")
    // if low < b_low and entry_price > low
    //     strategy.close("SHORT")