यह रणनीति कम जोखिम वाले ट्रेंड ट्रैकिंग ट्रेडिंग को प्राप्त करने के लिए ट्रेंड फ़िल्टरिंग और अस्थिरता फ़िल्टरिंग के साथ संयोजन में ट्रेंड दिशा की पहचान करने के लिए क्रॉस-पीरियड तकनीकी संकेतकों का उपयोग करती है।
खरीदने और बेचने के संकेतों को निर्धारित करने के लिए उच्च-निम्न बिंदु के ब्रेकआउट का उपयोग करें। जब कीमत 7 अवधि के उच्च स्तर को तोड़ती है, तो शॉर्ट जाएं, और जब यह 7 अवधि के निम्न स्तर को तोड़ती है, तो लंबी जाएं।
ट्रेंडफ्लेक्स सूचक मुख्य प्रवृत्ति दिशा निर्धारित करता है। यह सूचक दोहरी चिकनाई तकनीकों को जोड़ती है और प्रभावी रूप से प्रवृत्ति मध्य खंडों की पहचान कर सकती है। 1 से ऊपर का मूल्य एक ऊपर की प्रवृत्ति को इंगित करता है, जबकि -1 से नीचे का मूल्य एक नीचे की प्रवृत्ति को इंगित करता है। यहां हमें ट्रेंडफ्लेक्स > 1 के लिए लॉन्ग और < -1 शॉर्ट्स की आवश्यकता होती है, जिससे समेकन की स्थिति को फ़िल्टर किया जाता है।
उतार-चढ़ाव की सीमाओं की पहचान करने के लिए बोलिंगर बैंड का प्रयोग करें। बंद मूल्य बैंड के भीतर होने पर लॉन्ग और शॉर्ट्स से बचें।
पदों का प्रबंधन करने के लिए स्टॉप लॉस और ले लाभ का उपयोग करें।
क्रॉस-पीरियड इंडिकेटर दोहरे स्मूलिंग तकनीक के साथ मिलकर प्रभावी रूप से रुझान की दिशाओं की पहचान कर सकते हैं और अस्थिर बाजारों से बच सकते हैं।
रुझान दिशा और अस्थिरता पैटर्न दोनों को ध्यान में रखते हुए ट्रेडिंग सिग्नल अधिक विश्वसनीय होते हैं।
उचित स्टॉप लॉस और टेक प्रॉफिट सेटिंग्स मुनाफे को लॉक करती हैं और घाटे के विस्तार को रोकती हैं।
यह रणनीति अपेक्षाकृत सरल और लागू करने में आसान है।
ब्रेकआउट सिग्नल में झूठे ब्रेकआउट हो सकते हैं, जिसके परिणामस्वरूप गलत ट्रेड हो सकते हैं। अधिक फ़िल्टरिंग स्थितियों पर विचार किया जा सकता है।
निश्चित चक्र के मापदंड बाजार परिवर्तनों के अनुकूल नहीं हो सकते हैं। मापदंडों के गतिशील अनुकूलन पर विचार किया जा सकता है।
कीमतों में रुकावट न होने से चरम बाजार स्थितियों से होने वाले भारी नुकसान को रोका नहीं जा सकता।
बाजार की अस्थिरता के अनुसार निश्चित लाभ लेने और स्टॉप लॉस बिंदुओं को समझदारी से समायोजित नहीं किया जा सकता है।
निर्णय की सटीकता में सुधार के लिए रणनीति संयोजन बनाने के लिए अधिक प्रवृत्ति निर्णय संकेतक जोड़ने पर विचार करें।
जोखिम को कम करने के लिए उतार-चढ़ाव के गंभीर होने पर ट्रेडिंग को रोकने के लिए उतार-चढ़ाव पहचान मॉड्यूल जोड़ें।
गतिशील पैरामीटर अनुकूलन प्राप्त करने के लिए मशीन लर्निंग एल्गोरिदम पेश करें।
मूल्य स्टॉप लॉस मॉड्यूल जोड़ें जब हानि एक निश्चित सीमा तक पहुँचती है।
लाभ लेने और हानि रोकने के अनुपात की गणना बाजार की अस्थिरता के आधार पर लाभ लेने और हानि रोकने के बुद्धिमान समायोजन को प्राप्त करने के लिए करें।
कुल मिलाकर, यह रणनीति अपेक्षाकृत स्थिर और विश्वसनीय है, जबकि सुधार के लिए भी जगह है। मूल विचार चक्रों में प्रवृत्ति की दिशा निर्धारित करना है, और फिर उच्च गुणवत्ता वाले संकेत उत्पन्न करने के लिए प्रवृत्ति शक्ति संकेतकों और अस्थिरता संकेतकों का उपयोग करके फ़िल्टर करना है। यह सरल और व्यावहारिक रणनीति मध्यम और दीर्घकालिक रुझानों को ट्रैक करने के लिए बहुत उपयुक्त है। अधिक सशर्त निर्णयों और गतिशील पैरामीटर अनुकूलन को पेश करके, रणनीति प्रभाव में और सुधार किया जा सकता है।
/*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")