एलट्रट कछुए के प्रतिगमन की रणनीति

लेखक:चाओझांग, दिनांक: 2023-09-27 16:30:51
टैगः

अवलोकन

यह रणनीति कम जोखिम वाले ट्रेंड ट्रैकिंग ट्रेडिंग को प्राप्त करने के लिए ट्रेंड फ़िल्टरिंग और अस्थिरता फ़िल्टरिंग के साथ संयोजन में ट्रेंड दिशा की पहचान करने के लिए क्रॉस-पीरियड तकनीकी संकेतकों का उपयोग करती है।

रणनीति तर्क

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

  2. ट्रेंडफ्लेक्स सूचक मुख्य प्रवृत्ति दिशा निर्धारित करता है। यह सूचक दोहरी चिकनाई तकनीकों को जोड़ती है और प्रभावी रूप से प्रवृत्ति मध्य खंडों की पहचान कर सकती है। 1 से ऊपर का मूल्य एक ऊपर की प्रवृत्ति को इंगित करता है, जबकि -1 से नीचे का मूल्य एक नीचे की प्रवृत्ति को इंगित करता है। यहां हमें ट्रेंडफ्लेक्स > 1 के लिए लॉन्ग और < -1 शॉर्ट्स की आवश्यकता होती है, जिससे समेकन की स्थिति को फ़िल्टर किया जाता है।

  3. उतार-चढ़ाव की सीमाओं की पहचान करने के लिए बोलिंगर बैंड का प्रयोग करें। बंद मूल्य बैंड के भीतर होने पर लॉन्ग और शॉर्ट्स से बचें।

  4. पदों का प्रबंधन करने के लिए स्टॉप लॉस और ले लाभ का उपयोग करें।

लाभ विश्लेषण

  1. क्रॉस-पीरियड इंडिकेटर दोहरे स्मूलिंग तकनीक के साथ मिलकर प्रभावी रूप से रुझान की दिशाओं की पहचान कर सकते हैं और अस्थिर बाजारों से बच सकते हैं।

  2. रुझान दिशा और अस्थिरता पैटर्न दोनों को ध्यान में रखते हुए ट्रेडिंग सिग्नल अधिक विश्वसनीय होते हैं।

  3. उचित स्टॉप लॉस और टेक प्रॉफिट सेटिंग्स मुनाफे को लॉक करती हैं और घाटे के विस्तार को रोकती हैं।

  4. यह रणनीति अपेक्षाकृत सरल और लागू करने में आसान है।

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

  1. ब्रेकआउट सिग्नल में झूठे ब्रेकआउट हो सकते हैं, जिसके परिणामस्वरूप गलत ट्रेड हो सकते हैं। अधिक फ़िल्टरिंग स्थितियों पर विचार किया जा सकता है।

  2. निश्चित चक्र के मापदंड बाजार परिवर्तनों के अनुकूल नहीं हो सकते हैं। मापदंडों के गतिशील अनुकूलन पर विचार किया जा सकता है।

  3. कीमतों में रुकावट न होने से चरम बाजार स्थितियों से होने वाले भारी नुकसान को रोका नहीं जा सकता।

  4. बाजार की अस्थिरता के अनुसार निश्चित लाभ लेने और स्टॉप लॉस बिंदुओं को समझदारी से समायोजित नहीं किया जा सकता है।

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

  1. निर्णय की सटीकता में सुधार के लिए रणनीति संयोजन बनाने के लिए अधिक प्रवृत्ति निर्णय संकेतक जोड़ने पर विचार करें।

  2. जोखिम को कम करने के लिए उतार-चढ़ाव के गंभीर होने पर ट्रेडिंग को रोकने के लिए उतार-चढ़ाव पहचान मॉड्यूल जोड़ें।

  3. गतिशील पैरामीटर अनुकूलन प्राप्त करने के लिए मशीन लर्निंग एल्गोरिदम पेश करें।

  4. मूल्य स्टॉप लॉस मॉड्यूल जोड़ें जब हानि एक निश्चित सीमा तक पहुँचती है।

  5. लाभ लेने और हानि रोकने के अनुपात की गणना बाजार की अस्थिरता के आधार पर लाभ लेने और हानि रोकने के बुद्धिमान समायोजन को प्राप्त करने के लिए करें।

सारांश

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


/*backtest
start: 2023-08-27 00:00:00
end: 2023-09-26 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Eltrut", shorttitle="Eltrut Strat", overlay=true, pyramiding=0, default_qty_type= strategy.percent_of_equity,calc_on_order_fills=false, slippage=25,commission_type=strategy.commission.percent,commission_value=0.075)

testStartYear = input(2016, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)


// R E F L E X / T R E N D F L E X

f_supersmoother(_src,_len)=>
    pi = 2 * asin(1)
    _a = exp(-sqrt(2) * pi / _len)
    _c2 = 2 * _a * cos(sqrt(2) * pi / _len)
    _c3 = -_a * _a
    _c1 = 1 - _c2 - _c3
    _out = 0.0
    _out := _c1 * _src + _c2 * nz(_out[1],nz(_src[1],_src)) + _c3 * nz(_out[2],nz(_src[2],nz(_src[1],_src)))

f_IQIFM(_src1,_max)=>
    _src = _src1 < 0.001 ? _src1 * 10000 : _src1
    _imult = 0.635, _qmult = 0.338 , _inphase = 0.0, _quad = 0.0
    _re = 0.0, _im = 0.0, _deltaphase = 0.0, _instper = 0.0, _per = 0.0, _v4 = 0.0
    _v1 = _src - nz(_src[7])
    _inphase := 1.25 * (nz(_v1[4]) - _imult * _v1[2]) + _imult * nz(_inphase[3])
    _quad := _v1[2] - _qmult * _v1 + _qmult * nz(_quad[2])
    _re := 0.2 * (_inphase * _inphase[1] + _quad * _quad[1]) + 0.8 * nz(_re[1])
    _im := 0.2 * (_inphase * _quad[1] - _inphase[1] * _quad) + 0.8 * nz(_im[1])
    if _re != 0.0
        _deltaphase := atan(_im / _re)
    for i = 0 to _max
        _v4 := _v4 + _deltaphase[i]
        if _v4 > 4 * asin(1) and _instper == 0.0
            _instper := i
    if _instper == 0.0
        _instper := nz(_instper[1])
    _per := 0.25 * _instper + 0.75 * nz(_per[1])
    _per

f_flex(_src1, _fixed_len, _reflex) =>
    _src = _src1
    _len = _fixed_len 
    _ss1 = f_supersmoother(_src, _len)
    _ss = _ss1
    _slope = (_ss[_len] - _ss) / _len
    _sum = 0.0
    for _i = 1 to _len
        _c1 = _reflex ? _ss + _i * _slope - _ss[_i] : _ss - _ss[_i]
        _sum := _sum + _c1
    _sum := _sum / _len
    _ms = 0.0
    _ms := 0.04 * pow(_sum,2) + 0.96 * nz(_ms[1])
    _flex1 = _ms != 0 ? _sum / sqrt(nz(_ms)) : 0.0
    _flex = _flex1
    _flex

rflx = f_flex(close, 20, true)  
trndflx = f_flex(close, 20, false)   

// S I G N A L
hi7 = highest(7)
lo7 = lowest(7)
long_cond = crossunder(close, lo7[1])
short_cond = crossover(close, hi7[1])

// F I L T E R S

long_filter1 = trndflx < 1
short_filter1 = trndflx > -1

basis = sma(close, 35)
dev = 3 * stdev(close, 35)
long_filter2 = close > basis - dev
short_filter2 = close < basis + dev

// S T R A T E G Y

long = long_cond and long_filter1 and long_filter2
short = short_cond and short_filter1 and short_filter2

if( true)
    strategy.entry("Long", strategy.long, when = long)
    strategy.entry("Long", strategy.long, when = short)


// User Options to Change Inputs (%)
stopPer = input(3, title='Stop Loss %', type=input.float) / 100
takePer = input(9, title='Take Profit %', type=input.float) / 100

// Determine where you've entered and in what direction
longStop = strategy.position_avg_price * (1 - stopPer)
shortStop = strategy.position_avg_price * (1 + stopPer)
shortTake = strategy.position_avg_price * (1 - takePer)
longTake = strategy.position_avg_price * (1 + takePer)

if strategy.position_size > 0 
    strategy.exit(id="Exit Long", stop=longStop, limit=longTake)
if strategy.position_size < 0 
    strategy.exit(id="Exit Short", stop=shortStop, limit=shortTake)


// P L O T 

plotshape(long, color = #1e90ff, text = "", style=shape.triangleup, location=location.belowbar, size=size.tiny)
plotshape(short, color = #ff69b4, text = "", style=shape.triangledown, location=location.abovebar, size=size.tiny)

alertcondition(long, "Long", "Enter Long")
alertcondition(short, "Short", "Enter S")

अधिक