अत्यधिक अति फिट ट्रेंड ब्रेकआउट रणनीति

लेखक:चाओझांग, दिनांक: 2023-09-28 15:54:32
टैगः

सारांश

इस रणनीति का उद्देश्य ट्रेंड सिग्नल की पहचान करने के लिए कई चैनलों और चलती औसत का उपयोग करके क्रिप्टोक्यूरेंसी बाजारों में मजबूत रुझानों को कैप्चर करना है, और ट्रेंडिंग बाजारों में मुनाफे को लॉक करने के लिए अनुकूलनशील रूप से नुकसान को रोकने के साथ झूठे ब्रेकआउट को फ़िल्टर करने के लिए वॉल्यूम संकेतकों को जोड़ना है।

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

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

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

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

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

लाभ विश्लेषण

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

  1. कई चैनलों और चलती औसत के संयोजन में सख्त मानदंड हैं और गलत आकलन की संभावना को कम कर सकते हैं।

  2. के-लाइन अनुक्रम सत्यापन एक एकल विचलित के-लाइन से गलत संकेतों से बचाता है।

  3. मूल्य परिवर्तन दर सूचक को शामिल करने से यह निर्धारित किया जा सकता है कि क्या यह पुनरावृत्ति के अवसरों को खोने से बचने के लिए समेकन में प्रवेश कर गया है।

  4. वॉल्यूम इंडिकेटर जजमेंट जोड़ने से यह सुनिश्चित होता है कि केवल तभी संकेत उत्पन्न होते हैं जब वॉल्यूम कीमत का अनुसरण करता है, जिससे अप्रभावी ब्रेकआउट से बचा जा सकता है।

  5. अनुकूलन स्टॉप लॉस तंत्र स्टॉप लॉस सुनिश्चित करते हुए ट्रेंड मुनाफे में लॉक को अधिकतम कर सकता है।

तो सामान्य तौर पर, इस रणनीति में अनुकूलित विन्यास, विवेकपूर्ण निर्णय लेने, अनुकूलन स्टॉप लॉस की विशेषताएं हैं, जो इसे रुझान के अवसरों को पकड़ने के लिए बहुत उपयुक्त बनाती हैं।

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

यद्यपि इस रणनीति ने झूठे ब्रेकआउट को फ़िल्टर करने और रुझानों को पकड़ने में बहुत अधिक अनुकूलन किया है, फिर भी कुछ जोखिम हैं जिन्हें ध्यान में रखा जाना चाहिएः

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

  2. जब तेजी से चलती औसत और चैनल के बीच का अंतर बहुत छोटा होता है, तो यह अक्सर प्रवेश और निकास उत्पन्न करता है, जो रुझानों को लगातार ट्रैक करने के लिए अनुकूल नहीं होता है।

  3. अनुकूली स्टॉप लॉस तंत्र में स्टॉप लॉस प्रतिशत की गणना सरल मानक विचलन पर आधारित है, जिससे चरम बाजार स्थितियों में अपर्याप्त स्टॉप लॉस हो सकता है।

  4. यह तकनीकी संकेतकों पर बहुत निर्भर करता है और प्रमुख मौलिक परिवर्तनों का जवाब नहीं दे सकता है।

  5. रणनीति का अनुसरण करने वाले रुझान के रूप में, यह सीमा-बंद चंचल बाजारों में खराब प्रदर्शन करता है।

इन जोखिमों को नियंत्रित करने के लिए निम्नलिखित उपायों की सिफारिश की जाती हैः

  1. इष्टतम पैरामीटर संयोजन निर्धारित करने के लिए पर्याप्त बैकटेस्टिंग करें, या पैरामीटर अनुकूलन के लिए मशीन लर्निंग का उपयोग करने पर विचार करें।

  2. अनावश्यक प्रविष्टियों को कम करने के लिए मध्यम रूप से चैनल अंतराल को चौड़ा करें, चलती औसत अवधि को बढ़ाएं।

  3. हेज फंड के तरीकों जैसे अधिक उन्नत अस्थिरता मॉडल पेश करने पर विचार करें।

  4. विशुद्ध रूप से तकनीकी व्यापार से बचने के लिए समय पर मौलिक सूचनाओं का संदर्भ लें।

  5. बाजार की स्थिति का आकलन बढ़ाएं और अस्थिर बाजारों में व्यापार को रोकें।

अनुकूलन

इस रणनीति को निम्नलिखित तरीकों से और अधिक अनुकूलित किया जा सकता हैः

  1. गतिशील अनुकूलन के लिए खोज तालिका बनाने के लिए विभिन्न बाजार वातावरणों में पैरामीटर प्रदर्शन को रिकॉर्ड करके स्वचालित पैरामीटर अनुकूलन प्राप्त करने के लिए मशीन लर्निंग एल्गोरिदम पेश करना।

  2. बाजार स्थितियों पर निर्णय जोड़ें, जैसे कि यह निर्धारित करने के लिए मॉड्यूल जोड़ना कि बाजार ट्रेंडिंग है या अस्थिर है, और अनावश्यक नुकसान से बचने के लिए अस्थिर बाजारों में व्यापार को रोकें।

  3. स्टॉप लॉस रणनीतियों को अनुकूलित करें, जैसे कि ट्रेलिंग स्टॉप लॉस, आनुपातिक स्टॉप लॉस आदि।

  4. मौलिक कारकों को शामिल करें ताकि प्रमुख मौलिक घटनाओं के होने पर अलर्ट भेजा जा सके, जिससे केवल तकनीकी संकेतकों पर आधारित नुकसान से बचा जा सके।

  5. पोर्टफोलियो अनुकूलन करना, जोखिमों को और विविध बनाने के लिए इस रणनीति को अन्य संबंधित रणनीतियों के साथ जोड़ना।

  6. स्वचालित संकेत निष्पादन और सख्त जोखिम नियंत्रण के लिए मात्रात्मक व्यापार ढांचा लागू करना।

निष्कर्ष

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


/*backtest
start: 2022-09-21 00:00:00
end: 2023-09-27 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Extremely Overfit", overlay=true, commission_type=strategy.commission.percent, commission_value=.16, default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding = 1)
price = close

goLong = input(title="go long?", type=input.bool, defval=true)
goShort = input(title="go short?", type=input.bool, defval=true)
//trendRestrict = input(title="basic trend restriction?", type=input.bool, defval=false)
dynamicRestrict = true //input(title="dynamic trend restriction?", type=input.bool, defval=true)
longtrendimpt = true //input(title="additional weight on long-term trends?", type=input.bool, defval=true)
volRestrict = true //input(title="volume restriction?", type=input.bool, defval=true)
conservativeClose = false //input(title="conservative order closing?", type=input.bool, defval=false)

Restrictiveness = input ( -40,step=10,title ="Restrictiveness (higher = make fewer trades)")
volatilityImportance = 3.2 //input( 3.2, step = 0.1, minval = 0)
fastChannelLength = input( 6 )
fastChannelMargin = input ( 3.2, step = 0.1, minval = 0)
slowChannelLength = input ( 6, step = 1, minval = 0)
slowChannelMargin = input ( 1.5, step = 0.1, minval = 0)
fastHMAlength = input (4, step = 1, minval = 0)
stopLoss = input( 3, step = 0.1, minval = 0)
//altClosePeriod = input( 27, step = 1, minval = 1)
//altCloseFactor = input( 4.9, step = 0.1)
stopLossFlexibility = 50 //input(50, step=10, title="effect of volatility on SL?")
volumeMAlength = 14 //input ( 14, step = 1, minval = 1)
volumeVolatilityCutoff = 3.8 // ( 3.8, step = 1, minval = 0)
trendSensitivity = 3.8 //input ( 3.8, step = 0.1)
obvLookback = 10 //input(10, step = 10, minval = 10)
obvCorrThreshold = 0.89 //input(0.89, step = 0.01)
ROClength = 80 //input( 80, step = 10)
ROCcutoff = 5.6 //input( 5.6, step=0.1)

trendRestrict = false
//trendLookback = input ( 360, step = 10, minval = 10)
//longTrendLookback = input(720, step = 10, minval = 10)
//longTrendImportance = input(1.5, step = 0.05)
trendLookback = 360
longTrendLookback = 720
longTrendImportance = 1.5

//conservativeness = input( 2.4, step = 0.1)
conservativeness = 0
//trendPower = input( 0, step=1)
trendPower = 0
//conservativenessLookback = input( 650, step = 10, minval = 0)
conservativenessLookback = 10
//consAffectFactor = input( 0.85,step=0.01)
consAffectFactor = 0.85
//volatilityLookback = input(50, step=1, minval=2)
volatilityLookback = int(50)
recentVol = stdev(price,volatilityLookback)/sqrt(volatilityLookback)

//price channel

fastChannel = ema(price, fastChannelLength)
fastChannelUB = fastChannel * (1 + (float(fastChannelMargin) / 1000)) + (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
fastChannelLB = fastChannel * (1 - (float(fastChannelMargin) / 1000)) - (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
fchU = ((fastChannelUB < open) and (fastChannelUB < close))
fchL = ((fastChannelLB > open) and (fastChannelLB > close))
//plot(fastChannelUB)
//plot(fastChannelLB)

//slow channel
//slowChannelLBmargin = input ( 2, step = 0.1, minval = 0 )
slowChannel = ema(ema(price,slowChannelLength),slowChannelLength)
slowChannelUB = slowChannel * (1 + (float(slowChannelMargin) / 2000)) + (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
slowChannelLB = slowChannel * (1 - (float(slowChannelMargin) / 2000)) - (recentVol * (float(volatilityImportance) * (1 + (Restrictiveness/100))))
schU = ((slowChannelUB < close))
schL = ((slowChannelLB > close))
cschU = (((slowChannelUB * (1 + conservativeness)) < close))
cschL = (((slowChannelUB * (1 - conservativeness)) > close))
//plot(slowChannel,color = #00FF00)
//plot(slowChannelUB,color = #00FF00)
//plot(slowChannelLB,color = #00FF00)


fastHMA = hma(price,fastHMAlength)
fastAboveUB = (fastHMA > slowChannelUB)
fastBelowLB = (fastHMA < slowChannelLB)
//plot(fastHMA, color = 	#FF0000, linewidth = 2)

//consecutive candles
//consecutiveCandlesReq = input(1, step = 1, minval = 1, maxval = 4)
consecutiveCandlesReq = 1
consecutiveBullReq = float(consecutiveCandlesReq)
consecutiveBearReq = float(consecutiveCandlesReq)
cbull = ((close[0] > close[1]) and (consecutiveBullReq == 1)) or (((close[0] > close[1]) and (close[1] > close[2])) and consecutiveBullReq == 2) or (((close[0] > close[1]) and (close[1] > close[2]) and (close[2] > close[3])) and consecutiveBullReq == 3) or (((close[0] > close[1]) and (close[1] > close[2]) and (close[2] > close[3]) and (close[3] > close[4])) and consecutiveBullReq == 4)
cbear = ((close[0] < close[1]) and (consecutiveBearReq == 1)) or (((close[0] < close[1]) and (close[1] < close[2])) and consecutiveBearReq == 2) or (((close[0] < close[1]) and (close[1] < close[2]) and (close[2] < close[3])) and consecutiveBearReq == 3) or (((close[0] < close[1]) and (close[1] < close[2]) and (close[2] < close[3]) and (close[3] < close[4])) and consecutiveBearReq == 4)

//trend detection
//trendCutoff = input(0, step = 0.1)
trendCutoff = 0
trendDetectionPct = float(trendCutoff/100)
trendVal = float((close[0] - close[trendLookback])/close[0])
trendUp = (trendVal > (0 + trendDetectionPct))
trendDown = (trendVal < (0 - trendDetectionPct))
//plot(trendVal+36.5,linewidth=2)

// peak indicators
peakHigh = ((fastHMA > fastChannelUB) and (fastChannelLB > slowChannelUB))
peakLow = ((fastHMA < fastChannelLB) and (fastChannelUB < slowChannelLB))
TpeakHigh = (fastHMA > fastChannelUB) and (fastChannelUB > slowChannelUB)
TpeakLow = (fastHMA < fastChannelUB) and (fastChannelLB < slowChannelLB)
//TpeakHigh = (fastHMA > fastChannelUB) and (fastChannelLB > avg(slowChannelUB,slowChannelLB))
//TpeakLow = (fastHMA < fastChannelUB) and (fastChannelUB < avg(slowChannelLB,slowChannelUB))
//TpeakHigh = ((crossover(fastHMA,fastChannelUB)) and (fastChannelLB > slowChannelUB))
//TpeakLow = ((crossover(fastChannelLB,fastHMA)) and (fastChannelUB < slowChannelLB))
//TpeakHigh = (fastHMA > (fastChannelUB * (1 + (trendPower/800)))) and (fastChannelUB > (slowChannelUB * (1 + (trendPower/800))))
//TpeakLow = (fastHMA < (fastChannelUB * (1 - (trendPower/800)))) and (fastChannelLB < (slowChannelLB * (1 - (trendPower/800))))
//TpeakHigh = (fastHMA > (fastChannelUB * (1 + (trendPower/800)))) and (avg(fastChannelUB,fastChannelLB) > (slowChannelUB * (1 + (trendPower/800))))
//TpeakLow = (fastHMA < (fastChannelUB * (1 - (trendPower/800)))) and (avg(fastChannelLB,fastChannelUB) < (slowChannelLB * (1 - (trendPower/800))))
//plot(fastChannelUB * (1 + (trendPower/700)), color=#FF69B4)

// and for closing...
closeLong = (crossover(fastHMA,fastChannelUB) and (fastChannelLB > slowChannelUB))
closeShort = (crossover(fastChannelLB,fastHMA) and (fastChannelUB < slowChannelLB))
//closeLong = (crossover(fastHMA,fastChannelUB) and (fastChannelLB > slowChannelUB)) or (roc(price,altClosePeriod) > altCloseFactor)
//closeShort = (crossover(fastChannelLB,fastHMA) and (fastChannelUB < slowChannelLB))  or (roc(price,altClosePeriod) < (altCloseFactor) * -1)
//closeLong = (crossover(fastHMA,fastChannelUB) and (fastChannelLB > slowChannelUB)) or (((price - fastChannelUB) > (altCloseFactor * abs(((fastChannelUB - fastChannelLB)/2) - ((slowChannelUB - slowChannelLB)/2)))) and (fastChannelLB > slowChannelUB))
//closeShort = (crossover(fastChannelLB,fastHMA) and (fastChannelUB < slowChannelLB)) or (((fastChannelLB - price) > (altCloseFactor * abs(((fastChannelUB - fastChannelLB)/2) - ((slowChannelUB - slowChannelLB)/2)))) and (fastChannelUB < slowChannelLB))
//closeLong = crossover(fastHMA,fastChannelUB) and ((fastChannelLB[0] - fastChannelLB[1]) < (slowChannelUB[0] - slowChannelUB[1]))
//closeShort = crossover(fastChannelLB,fastHMA) and ((fastChannelUB[0] - fastChannelUB[1]) > (slowChannelLB[0] - slowChannelLB[1]))


//stop-loss
priceDev = stdev(price,trendLookback) * (1 + stopLossFlexibility/5)
stopLossMod = stopLoss * (1 + (priceDev/price))
//longStopPrice  = strategy.position_avg_price * (1 - (stopLoss/100))
//shortStopPrice = strategy.position_avg_price * (1 + (stopLoss/100))
longStopPrice  = strategy.position_avg_price * (1 - (stopLossMod/100))
shortStopPrice = strategy.position_avg_price * (1 + (stopLossMod/100))


// volume
volumeMA = ema(volume,volumeMAlength)
volumeDecrease = ((not volRestrict ) or (volumeMA[0] < ema(volumeMA[1] * (1 - (volumeVolatilityCutoff/100)),5)))
volumeCutoff = ema(volumeMA[1] * (1 - (volumeVolatilityCutoff/100)),5)
//plot(volumeMA)
//plot(volumeCutoff)

// detect volatility
//trendinessLookback = input ( 600, step = 10, minval = 0)
trendinessLookback = trendLookback
trendiness = (stdev(price,trendinessLookback)/price) * (1 - (Restrictiveness/100))
longtermTrend = ((price - price[longTrendLookback])/price)
//dynamicTrendDetected = (dynamicRestrict and (abs(trendiness * 100) < trendSensitivity))
dynamicTrendDetected = (longtrendimpt and (dynamicRestrict and (abs(trendiness * 100) < (trendSensitivity+(longtermTrend * longTrendImportance))))) or (not longtrendimpt and ((dynamicRestrict and (abs(trendiness * 100) < trendSensitivity))))

// adapt conservativeness to volatility

//consVal = sma(((stdev(price,conservativenessLookback))/price)*100,25)
consVal = sma(((stdev(price,conservativenessLookback))/price)*100,25)
cVnorm = sma(avg(consVal,3),60)
cVal = consVal - cVnorm

//conservativenessMod = conservativeness * (cVal * consAffectFactor)
conservativenessMod = conservativeness * (consVal * consAffectFactor)
//plot(consVal,linewidth=4)
//plot(cVnorm,color = #00FF00)
//plot(cVal,linewidth=2)

// ROC cutoff (for CLOSING)
//rocCloseLong = (ema(roc(price,ROClength),10) > ROCcutoff)
//rocCloseShort = (ema(roc(price,ROClength),10) < (ROCcutoff * -1))
ROCval = roc(price,ROClength)
ROCema = ema(ROCval,30)
ROCabs = abs(ROCema)
ROCallow = ROCabs < ROCcutoff
ROCallowLong = (ROCabs < ROCcutoff)  or ((ROCabs >= ROCcutoff) and ((fastChannelLB < slowChannelLB) and (fastHMA < fastChannelLB)))
ROCallowShort = (ROCabs < ROCcutoff) or ((ROCabs >= ROCcutoff) and ((fastChannelUB > slowChannelUB) and (fastHMA > fastChannelUB)))
//plot(ROCallow)

// obv
evidence_obv = (correlation(price,obv[0],obvLookback))
obvAllow = evidence_obv > obvCorrThreshold


//if (not na(vrsi))
if trendRestrict or dynamicTrendDetected
    //if (strategy.position_size == 0)
    if not (strategy.position_size < 0)
        if trendUp
        	//if cbear and schL and fchL and trendUp and goLong
        	if cbear and TpeakLow and volumeDecrease and ROCallow and goLong and obvAllow
        	//if cbear and peakLow and rocHigh and volumeDecrease and goLong
        		strategy.entry("Long", strategy.long, comment="Long")
    if not (strategy.position_size > 0)
        if trendDown
        	//if cbull and schU and fchU and trendDown and goShort
        	if cbull and TpeakHigh and volumeDecrease and ROCallow and goShort and obvAllow
        	//if cbull and peakHigh and rocLow and volumeDecrease and goShort
        		strategy.entry("Short", strategy.short, comment="Short")
else
    //if (strategy.position_size == 0)
    if not (strategy.position_size < 0)
        //if cbear and peakLow and goLong
    	//if cbear and peakLow and volumeDecrease and ROCallow and goLong
    	if TpeakLow and goLong and obvAllow
    		strategy.entry("Long", strategy.long, comment="Long")
    if not (strategy.position_size > 0)
        //if cbull and peakHigh and goShort
    	//if cbull and peakHigh and volumeDecrease and ROCallow and goShort
    	if TpeakHigh and goShort and obvAllow
    		strategy.entry("Short", strategy.short, comment="Short")

if conservativeClose
    //pkHigh = ((fastHMA > fastChannelUB) and (fastChannelUB > (slowChannelUB * (1 + conservativeness/1000))))
    //pkLow = ((fastHMA < fastChannelLB) and (fastChannelLB < (slowChannelLB * (1 - conservativeness/1000))))
    //pkHigh = ((fastHMA > fastChannelUB) and (fastChannelUB > (slowChannelUB * (1 + conservativenessMod/1000))))
    //pkLow = ((fastHMA < fastChannelLB) and (fastChannelLB < (slowChannelLB * (1 - conservativenessMod/1000))))
    pkHigh = ((fastHMA > fastChannelUB) and (fastChannelUB > (slowChannelUB * (1 + ((conservativenessMod/1000) * (1 - Restrictiveness/100))))))
    pkLow = ((fastHMA < fastChannelLB) and (fastChannelLB < (slowChannelLB * (1 - ((conservativenessMod/1000) * (1 - Restrictiveness/100))))))
    
    if (strategy.position_size > 0)
        //if fastAboveUB
        //if pkHigh and closeLong
        if closeLong
    		strategy.close("Long", comment="closeLong")
    if (strategy.position_size < 0)
        //if fastBelowLB
        //if pkLow and closeShort
        if closeShort
    		strategy.close("Short", comment="closeShort")
else
    if (strategy.position_size > 0)
        //if fastAboveUB
        if peakHigh
    		strategy.close("Long", comment="closeLong")
    if (strategy.position_size < 0)
        //if fastBelowLB
        if peakLow
    		strategy.close("Short", comment="closeShort")

if (strategy.position_size > 0)
    strategy.exit(id="Long", stop=longStopPrice, comment="stopLong")

if (strategy.position_size < 0)
    strategy.exit(id="Short", stop=shortStopPrice, comment="stopShort")
//plot(strategy.equity, title="equity", color=color.red, linewidth=2, style=plot.style_areabr)












अधिक