बहु-समय फ़्रेम गति रोटेशन पर आधारित प्रवृत्ति अनुसरण रणनीति


निर्माण तिथि: 2023-11-17 17:32:11 अंत में संशोधित करें: 2023-11-17 17:32:11
कॉपी: 1 क्लिक्स: 710
1
ध्यान केंद्रित करना
1617
समर्थक

बहु-समय फ़्रेम गति रोटेशन पर आधारित प्रवृत्ति अनुसरण रणनीति

अवलोकन

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

मूल व्याख्या

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

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

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

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

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

  • विन्यास में लचीलापन, उपयोगकर्ता अलग-अलग किस्मों और ट्रेडिंग वरीयताओं के लिए अपने स्वयं के चलती औसत पैरामीटर को समायोजित कर सकते हैं

  • सरल और नौसिखिए उपयोगकर्ताओं के लिए भी आसान

  • उच्च दक्षता के साथ पूंजी का लाभ उठाने के लिए

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

  • प्रवृत्ति का पीछा करने की क्षमता, महाचक्र के बाद निरंतर लाभ

  • उच्च जीत दर, अच्छी ट्रेडिंग सिग्नल गुणवत्ता, कम लेन-देन त्रुटि

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

  • बड़ी अवधि के निर्णयों को स्थानांतरित औसत रेखा पर निर्भर करता है, जो गलत निर्णय के जोखिम के साथ है

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

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

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

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

संक्षेप

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

Overview

This strategy uses a combination of moving averages across timeframes to identify trend rotations on the hourly, daily and weekly charts. It allows low-risk trend following trading. The strategy is flexible, simple to implement, capital efficient and suitable for medium-long term trend traders.

Trading Logic

The strategy employs 5, 20 and 40-day moving averages to determine the alignment of trends across different timeframes. Based on the consistency between larger and smaller timeframes, it identifies bullish and bearish cycles.

Specifically, the crossing of 5-day fast MA above 20-day medium MA indicates an uptrend in the short term. The crossing of 20-day medium MA above 40-day slow MA signals an uptrend in the medium term. When the fast, medium and slow MAs are positively aligned (5-day > 20-day > 40-day), it is a bull cycle. When they are negatively aligned (5-day < 20-day < 40-day), it is a bear cycle.

By determining direction from the larger cycles and confirming strength on the smaller cycles, this strategy opens positions only when major trend and minor momentum align. This effectively avoids false breakouts and achieves high win rate.

The strategy also utilizes ATR trailing stops to control single trade risks and further improve profitability.

Advantages

  • Flexible configurations to suit different instruments and trading styles

  • Simple to implement even for beginner traders

  • High capital efficiency to maximize leverage

  • Effective risk control to avoid significant losses

  • Strong trend following ability for sustained profits

  • High win rate due to robust signals and fewer whipsaws

Risks and Improvements

  • MA crossovers may lag and cause late trend detection

  • Single candle strength detection could trigger premature entry, relax condition

  • Fixed ATR stop loss, optimize to dynamic stops

  • Consider adding supplementary filters like volume

  • Explore different MA parameters for optimization

Conclusion

This strategy integrates multiple timeframe analysis and risk management for low-risk trend following trading. By adjusting parameters, it can be adapted to different instruments to suit trend traders. Compared to single timeframe systems, it makes more robust trading decisions and generates higher efficiency signals. In conclusion, this strategy has good market adaptiveness and development potential.

रणनीति स्रोत कोड
/*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))