संसाधन लोड हो रहा है... लोड करना...

समय सीमाओं में गति का रोटेशन रणनीति का पालन करना

लेखक:चाओझांग, दिनांकः 2023-11-17 17:32:11
टैगः

img

अवलोकन

यह रणनीति समय-सीमा के पार चलती औसत रेखाओं के संयोजन का उपयोग करती है, जो बड़े और मध्यम घंटे के चार्ट पर रुझान रोटेशन की पहचान करती है और कम जोखिम वाले रुझानों को ट्रैक करती है। यह रणनीति लचीली विन्यास, सरलता और उच्च पूंजी दक्षता के लाभों को प्राप्त करती है, जो मध्यम और लंबी लाइनों के लिए ट्रेडरों के लिए उपयुक्त है।

मूल समझ

रणनीति 5 दिन, 20 दिन और 40 दिन के तीन चलती औसत का उपयोग करती है, जो विभिन्न समय सीमाओं के तहत रुझानों के क्रमबद्ध संयोजनों को निर्धारित करती है।

विशेष रूप से, 5 दिन की तेजी से लाइन पर 20 दिन की मध्य रेखा को पार करने के लिए एक छोटी लाइन के रूप में माना जाता है, और 20 दिन की धीमी लाइन पर 40 दिन की धीमी लाइन को पार करने के लिए एक मध्यम लाइन के रूप में माना जाता है। जब तेजी से धीमी 3 लाइन सही है ((5 दिन > 20 दिन > 40 दिन), बहु-आयामी चक्र के रूप में न्याय किया जाता है; जब तेजी से धीमी 3 लाइन उलट है ((5 दिन < 20 दिन < 40 दिन), खाली सिर चक्र के रूप में न्याय किया जाता है।

इस प्रकार, बड़े चक्र की प्रवृत्ति की दिशा के आधार पर, छोटे चक्र की ताकत के साथ संयोजन में विशिष्ट प्रविष्टि का पता लगाया जाता है; यानी, केवल बड़े प्रवृत्ति के साथ-साथ छोटे चक्र के साथ एक मजबूत स्थिति में ही ट्रेड खोलना, प्रभावी रूप से रिवर्स झूठे ब्रेक को फ़िल्टर कर सकता है, उच्च जीत दर ऑपरेशन प्राप्त कर सकता है।

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

फायदे का विश्लेषण

  • कॉन्फ़िगरेशन लचीला, उपयोगकर्ता विभिन्न किस्मों और लेनदेन की प्राथमिकताओं के लिए स्वचालित रूप से गतिशील औसत पैरामीटर समायोजित कर सकते हैं

  • इसे लागू करना आसान है और इसे नए उपयोगकर्ताओं के लिए भी उपयोग करना आसान है।

  • उच्च दक्षता के साथ धन का उपयोग करें और धन के लाभ का पूरा लाभ उठाएं

  • जोखिम को नियंत्रित करना और बड़े नुकसान से बचने के लिए प्रभावी नुकसान को रोकने के तंत्र

  • प्रवृत्ति का पालन करने की क्षमता मजबूत है, बड़े चक्र ने दिशा निर्धारित करने के बाद लगातार लाभ

  • उच्च जीत की दर, व्यापार संकेत की गुणवत्ता, कम गलत लेनदेन

जोखिम और सुधार

  • बड़े चक्र निर्धारण के आधार पर विचलन औसत रेखा क्रमबद्ध, वहाँ देरी से गलत फैसले का जोखिम है

  • छोटे चक्र के बल का पता लगाने के लिए केवल एक K-लाइन का उपयोग करें, जो पहले से शुरू हो सकता है और उचित रूप से आराम कर सकता है

  • गतिशील क्षति के लिए अनुकूलित, स्थिर क्षति को रोकना

  • अतिरिक्त फ़िल्टरिंग शर्तों को जोड़ने पर विचार किया जा सकता है, जैसे कि लेन-देन की मात्रा ऊर्जा आदि

  • विभिन्न चलती औसत पैरामीटर संयोजनों का प्रयास करें, रणनीतियों को अनुकूलित करें

सारांश

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

अवलोकन

यह रणनीति घंटात्मक, दैनिक और साप्ताहिक चार्ट पर रुझान रोटेशन की पहचान करने के लिए समय सीमाओं में चलती औसत के संयोजन का उपयोग करती है। यह व्यापार के बाद कम जोखिम वाले रुझान की अनुमति देती है। यह रणनीति लचीली, लागू करने में आसान, पूंजी कुशल और मध्यम-लंबी अवधि के रुझान व्यापारियों के लिए उपयुक्त है।

व्यापारिक तर्क

रणनीति विभिन्न समय सीमाओं में रुझानों के संरेखण को निर्धारित करने के लिए 5, 20 और 40 दिन के चलती औसत का उपयोग करती है। बड़े और छोटे समय सीमाओं के बीच स्थिरता के आधार पर, यह तेजी और मंदी चक्रों की पहचान करती है।

विशेष रूप से, 20-दिवसीय मध्यम एमए के ऊपर 5-दिवसीय तेजी से एमए का क्रॉसिंग अल्पकालिक में एक अपट्रेंड का संकेत देता है। 40-दिवसीय धीमी एमए के ऊपर 20-दिवसीय मध्यम एमए का क्रॉसिंग मध्यम अवधि में एक अपट्रेंड का संकेत देता है। जब तेज, मध्यम और धीमी एमए सकारात्मक रूप से संरेखित होते हैं (5-दिवसीय > 20-दिवसीय > 40-दिवसीय), यह एक बैल चक्र है। जब वे नकारात्मक रूप से संरेखित होते हैं (5-दिवसीय < 20-दिवसीय < 40-दिवसीय), यह एक भालू चक्र है।

बड़े चक्रों से दिशा निर्धारित करके और छोटे चक्रों पर ताकत की पुष्टि करके, यह रणनीति केवल तभी पद खोलती है जब प्रमुख प्रवृत्ति और मामूली गति संरेखित होती है। यह प्रभावी रूप से झूठे ब्रेकआउट से बचाता है और उच्च जीत दर प्राप्त करता है।

इस रणनीति में एकल व्यापार जोखिमों को नियंत्रित करने और लाभप्रदता में और सुधार करने के लिए एटीआर ट्रैलिंग स्टॉप का भी उपयोग किया गया है।

लाभ

  • विभिन्न साधनों और व्यापारिक शैलियों के अनुरूप लचीला विन्यास

  • शुरुआती व्यापारियों के लिए भी लागू करने के लिए सरल

  • अधिकतम लाभ के लिए उच्च पूंजी दक्षता

  • महत्वपूर्ण नुकसान से बचने के लिए प्रभावी जोखिम नियंत्रण

  • निरंतर लाभ के लिए क्षमता के बाद मजबूत प्रवृत्ति

  • मजबूत संकेतों और कम फटकारों के कारण उच्च जीत दर

जोखिम और सुधार

  • एमए क्रॉसओवर में देरी हो सकती है और देर से रुझान का पता लग सकता है

  • एकल मोमबत्ती की ताकत का पता लगाना समय से पहले प्रवेश, आराम की स्थिति को ट्रिगर कर सकता है

  • स्थिर एटीआर स्टॉप हानि, गतिशील स्टॉप के लिए अनुकूलित

  • वॉल्यूम जैसे अतिरिक्त फ़िल्टर जोड़ने पर विचार करें

  • अनुकूलन के लिए विभिन्न एमए मापदंडों का अन्वेषण

निष्कर्ष

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


/*backtest
start: 2023-10-17 00:00:00
end: 2023-11-16 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © kgynofomo

//@version=5
strategy(title="[Salavi] | Andy Advance Pro Strategy [BTC|M15]",overlay = true, pyramiding = 1,initial_capital = 10000, default_qty_type = strategy.cash,default_qty_value = 10000)

ema_short = ta.ema(close,5)
ema_middle = ta.ema(close,20)
ema_long = ta.ema(close,40)

cycle_1 = ema_short>ema_middle and ema_middle>ema_long
cycle_2 = ema_middle>ema_short and ema_short>ema_long
cycle_3 = ema_middle>ema_long and ema_long>ema_short
cycle_4 = ema_long>ema_middle and ema_middle>ema_short
cycle_5 = ema_long>ema_short and ema_short>ema_middle
cycle_6 = ema_short>ema_long and ema_long>ema_middle

bull_cycle = cycle_1 or cycle_2 or cycle_3
bear_cycle = cycle_4 or cycle_5 or cycle_6
// label.new("cycle_1")
// bgcolor(color=cycle_1?color.rgb(82, 255, 148, 60):na)
// bgcolor(color=cycle_2?color.rgb(82, 255, 148, 70):na)
// bgcolor(color=cycle_3?color.rgb(82, 255, 148, 80):na)
// bgcolor(color=cycle_4?color.rgb(255, 82, 82, 80):na)
// bgcolor(color=cycle_5?color.rgb(255, 82, 82, 70):na)
// bgcolor(color=cycle_6?color.rgb(255, 82, 82, 60):na)

// Inputs
a = input(2, title='Key Vaule. \'This changes the sensitivity\'')
c = input(7, title='ATR Period')
h = false

xATR = ta.atr(c)
nLoss = a * xATR

src = h ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close, lookahead=barmerge.lookahead_off) : close

xATRTrailingStop = 0.0
iff_1 = src > nz(xATRTrailingStop[1], 0) ? src - nLoss : src + nLoss
iff_2 = src < nz(xATRTrailingStop[1], 0) and src[1] < nz(xATRTrailingStop[1], 0) ? math.min(nz(xATRTrailingStop[1]), src + nLoss) : iff_1
xATRTrailingStop := src > nz(xATRTrailingStop[1], 0) and src[1] > nz(xATRTrailingStop[1], 0) ? math.max(nz(xATRTrailingStop[1]), src - nLoss) : iff_2

pos = 0
iff_3 = src[1] > nz(xATRTrailingStop[1], 0) and src < nz(xATRTrailingStop[1], 0) ? -1 : nz(pos[1], 0)
pos := src[1] < nz(xATRTrailingStop[1], 0) and src > nz(xATRTrailingStop[1], 0) ? 1 : iff_3

xcolor = pos == -1 ? color.red : pos == 1 ? color.green : color.blue

ema = ta.ema(src, 1)
above = ta.crossover(ema, xATRTrailingStop)
below = ta.crossover(xATRTrailingStop, ema)

buy = src > xATRTrailingStop and above
sell = src < xATRTrailingStop and below

barbuy = src > xATRTrailingStop
barsell = src < xATRTrailingStop




atr = ta.atr(14)
atr_length = input.int(25)
atr_rsi = ta.rsi(atr,atr_length)
atr_valid = atr_rsi>50

long_condition =  buy and bull_cycle and atr_valid
short_condition =  sell and bear_cycle and atr_valid

Exit_long_condition = short_condition
Exit_short_condition = long_condition

if long_condition
    strategy.entry("Andy Buy",strategy.long, limit=close,comment="Andy Buy Here")

if Exit_long_condition
    strategy.close("Andy Buy",comment="Andy Buy Out")
    // strategy.entry("Andy fandan Short",strategy.short, limit=close,comment="Andy 翻單 short Here")
    // strategy.close("Andy fandan Buy",comment="Andy short Out")


if short_condition
    strategy.entry("Andy Short",strategy.short, limit=close,comment="Andy short Here")


// strategy.exit("STR","Long",stop=longstoploss)
if Exit_short_condition
    strategy.close("Andy Short",comment="Andy short Out")
    // strategy.entry("Andy fandan Buy",strategy.long, limit=close,comment="Andy 翻單 Buy Here")
    // strategy.close("Andy fandan Short",comment="Andy Buy Out")




inLongTrade = strategy.position_size > 0
inLongTradecolor = #58D68D
notInTrade = strategy.position_size == 0
inShortTrade = strategy.position_size < 0

// bgcolor(color = inLongTrade?color.rgb(76, 175, 79, 70):inShortTrade?color.rgb(255, 82, 82, 70):na)
plotshape(close!=0,location = location.bottom,color = inLongTrade?color.rgb(76, 175, 79, 70):inShortTrade?color.rgb(255, 82, 82, 70):na)


plotshape(long_condition, title='Buy', text='Andy Buy', style=shape.labelup, location=location.belowbar, color=color.new(color.green, 0), textcolor=color.new(color.white, 0), size=size.tiny)
plotshape(short_condition, title='Sell', text='Andy Sell', style=shape.labeldown, location=location.abovebar, color=color.new(color.red, 0), textcolor=color.new(color.white, 0), size=size.tiny)


//atr > close *0.01* parameter

// MONTHLY TABLE PERFORMANCE - Developed by @QuantNomad
// *************************************************************************************************************************************************************************************************************************************************************************
show_performance = input.bool(true, 'Show Monthly Performance ?', group='Performance - credits: @QuantNomad')
prec = input(2, 'Return Precision', group='Performance - credits: @QuantNomad')

if show_performance
    new_month = month(time) != month(time[1])
    new_year  = year(time)  != year(time[1])
    
    eq = strategy.equity
    
    bar_pnl = eq / eq[1] - 1
    
    cur_month_pnl = 0.0
    cur_year_pnl  = 0.0
    
    // Current Monthly P&L
    cur_month_pnl := new_month ? 0.0 : 
                     (1 + cur_month_pnl[1]) * (1 + bar_pnl) - 1 
    
    // Current Yearly P&L
    cur_year_pnl := new_year ? 0.0 : 
                     (1 + cur_year_pnl[1]) * (1 + bar_pnl) - 1  
    
    // Arrays to store Yearly and Monthly P&Ls
    var month_pnl  = array.new_float(0)
    var month_time = array.new_int(0)
    
    var year_pnl  = array.new_float(0)
    var year_time = array.new_int(0)
    
    last_computed = false
    
    if (not na(cur_month_pnl[1]) and (new_month or barstate.islastconfirmedhistory))
        if (last_computed[1])
            array.pop(month_pnl)
            array.pop(month_time)
            
        array.push(month_pnl , cur_month_pnl[1])
        array.push(month_time, time[1])
    
    if (not na(cur_year_pnl[1]) and (new_year or barstate.islastconfirmedhistory))
        if (last_computed[1])
            array.pop(year_pnl)
            array.pop(year_time)
            
        array.push(year_pnl , cur_year_pnl[1])
        array.push(year_time, time[1])
    
    last_computed := barstate.islastconfirmedhistory ? true : nz(last_computed[1])
    
    // Monthly P&L Table    
    var monthly_table = table(na)
    
    if (barstate.islastconfirmedhistory)
        monthly_table := table.new(position.bottom_center, columns = 14, rows = array.size(year_pnl) + 1, border_width = 1)
    
        table.cell(monthly_table, 0,  0, "",     bgcolor = #cccccc)
        table.cell(monthly_table, 1,  0, "Jan",  bgcolor = #cccccc)
        table.cell(monthly_table, 2,  0, "Feb",  bgcolor = #cccccc)
        table.cell(monthly_table, 3,  0, "Mar",  bgcolor = #cccccc)
        table.cell(monthly_table, 4,  0, "Apr",  bgcolor = #cccccc)
        table.cell(monthly_table, 5,  0, "May",  bgcolor = #cccccc)
        table.cell(monthly_table, 6,  0, "Jun",  bgcolor = #cccccc)
        table.cell(monthly_table, 7,  0, "Jul",  bgcolor = #cccccc)
        table.cell(monthly_table, 8,  0, "Aug",  bgcolor = #cccccc)
        table.cell(monthly_table, 9,  0, "Sep",  bgcolor = #cccccc)
        table.cell(monthly_table, 10, 0, "Oct",  bgcolor = #cccccc)
        table.cell(monthly_table, 11, 0, "Nov",  bgcolor = #cccccc)
        table.cell(monthly_table, 12, 0, "Dec",  bgcolor = #cccccc)
        table.cell(monthly_table, 13, 0, "Year", bgcolor = #999999)
    
    
        for yi = 0 to array.size(year_pnl) - 1
            table.cell(monthly_table, 0,  yi + 1, str.tostring(year(array.get(year_time, yi))), bgcolor = #cccccc)
            
            y_color = array.get(year_pnl, yi) > 0 ? color.new(color.teal, transp = 40) : color.new(color.gray, transp = 40)
            table.cell(monthly_table, 13, yi + 1, str.tostring(math.round(array.get(year_pnl, yi) * 100, prec)), bgcolor = y_color, text_color=color.new(color.white, 0))
            
        for mi = 0 to array.size(month_time) - 1
            m_row   = year(array.get(month_time, mi))  - year(array.get(year_time, 0)) + 1
            m_col   = month(array.get(month_time, mi)) 
            m_color = array.get(month_pnl, mi) > 0 ? color.new(color.teal, transp = 40) : color.new(color.gray, transp = 40)
            
            table.cell(monthly_table, m_col, m_row, str.tostring(math.round(array.get(month_pnl, mi) * 100, prec)), bgcolor = m_color, text_color=color.new(color.white, 0))



अधिक