इस रणनीति में प्रवृत्ति की दिशा की पहचान करने के लिए कई संकेतकों का उपयोग किया गया है, और प्रवृत्ति को ट्रैक करने के तरीके को अपनाया गया है, और मध्य-छोटी रेखा पर प्रवृत्ति के अवसरों को पकड़ने के लिए। रणनीति को विशेष रूप से प्रवृत्ति को ट्रैक करने के लिए डिज़ाइन किया गया है, जिसका उद्देश्य जीत की दर को बढ़ाना और पीछे हटने को कम करना है।
WVAP सूचकांक का उपयोग करके मूल्य अनुपात का आकलन करें;
आरएसआई सूचकांक ओवरहेड गतिशीलता का आकलन करता है;
QQE सूचकांक ने कीमतों में वृद्धि की पहचान की;
ADX सूचकांक प्रवृत्ति की ताकत का आकलन करता है।
कोरल ट्रेंड इंडिकेटर के आधारभूत रुझानों का आकलन करने के लिए
एलएसएमए सूचकांक ट्रेंड्स को समझने में मदद करता है;
कई संकेतकों के संकेतों के संयोजन से ट्रेडिंग सिग्नल उत्पन्न होते हैं।
यह रणनीति मुख्य रूप से आरएसआई, क्यूक्यूई, एडीएक्स आदि जैसे कई संकेतकों पर निर्भर करती है, जो रुझान की दिशा और ताकत को निर्धारित करती है, और कोरल ट्रेंड इंडिकेटर की वक्रता को मूलभूत प्रवृत्ति निर्णय मानदंड के रूप में उपयोग करती है। जब आरएसआई जैसे संकेतक एक खरीद संकेत देते हैं, तो यदि कोरल ट्रेंड इंडिकेटर भी ऊपर की ओर वक्रता दिखाता है, तो उच्च संभावना ऊपर की ओर प्रवृत्ति से मेल खाती है, तो रणनीति खरीदने का विकल्प चुनती है। डब्ल्यूवीएपी जैसे संकेतक मुख्य रूप से यह निर्धारित करने के लिए उपयोग किए जाते हैं कि क्या कीमत उचित है, उच्च बुकिंग से बचें।
एक बहु-सूचक संयोजन, निर्णय की सटीकता में सुधार;
इस अवसर पर उन्होंने कहा, “हमारे लिए यह एक बहुत बड़ी उपलब्धि है।
ट्रेडिंग रेंज के बाजार को तोड़ने के लिए एक नए विचार का उपयोग करना;
मूलभूत सूचकांकों के संयोजन के साथ, नकारात्मक व्यापार से बचें;
ट्रेडिंग के समय और घंटों को तर्कसंगत रूप से सेट करें ताकि जोखिम कम हो सके;
यह स्पष्ट, समझने और अनुकूलित करने में आसान है।
इस रणनीति का सबसे बड़ा लाभ यह है कि बहु-सूचक संयोजन निर्णय, एक एकल सूचक गलतफहमी की संभावना को कम करने के लिए, निर्णय की सटीकता में सुधार कर सकते हैं। साथ ही प्रवृत्ति पर नज़र रखने और विचार को तोड़ने पर जोर देते हैं, जो निकटता में शॉर्ट-लाइन अवसरों को छानने के लिए सहायक है। इसके अलावा, रणनीति में मूलभूत संकेतकों को शामिल करने से प्रतिगामी संचालन से बचा जा सकता है। इन डिजाइनों ने रणनीति की स्थिरता और लाभप्रदता को बढ़ाया है।
यह भी कहा गया है कि यह एक “अतिरिक्त समय” है, और यह “अतिरिक्त समय” के लिए एक “अतिरिक्त समय” है, और “अतिरिक्त समय” के लिए “अतिरिक्त समय” है।
यह भी कहा गया है कि इस तरह के प्रतिबंधों के कारण, भारत के पास अपनी सीमाओं को पार करने के लिए पर्याप्त संसाधन नहीं हैं।
जब मौलिकता बदलती है, तो रणनीति संकेतों को याद कर सकती है;
लेनदेन की लागत को ध्यान में रखे बिना, वास्तविक उपयोग में लाभ में गिरावट का जोखिम है।
इस रणनीति का सबसे बड़ा जोखिम यह है कि बहु-सूचक संयोजन निर्णय में विलंब हो सकता है, जिससे सबसे अच्छा प्रवेश समय छूट जाता है, जिससे लाभप्रदता का क्षेत्र प्रभावित होता है। इसके अलावा, रणनीति का वापसी नियंत्रण आदर्श नहीं है, और वापसी का एक बड़ा जोखिम है। जब बाजार के मूलभूत बदलाव होते हैं और संकेतक अभी तक प्रतिबिंबित नहीं होते हैं, तो नुकसान पैदा करने की संभावना होती है। वास्तविक अनुप्रयोग में, लेनदेन की लागत भी आय पर कुछ प्रभाव डाल सकती है।
यह भी कहा गया है, “यह एक बहुत ही महत्वपूर्ण कदम है, लेकिन यह एक बहुत ही महत्वपूर्ण कदम है।
पैरामीटर सेटिंग को अनुकूलित करें, सूचक विलंब को कम करें;
बुनियादी सूचकांकों के उपयोग में वृद्धि और उनकी सटीकता में सुधार;
गतिशील पैरामीटर अनुकूलन के लिए मशीन लर्निंग एल्गोरिदम के साथ संयोजन।
इस रणनीति के अनुकूलन पर ध्यान देना चाहिए वापसी नियंत्रण, लाभ को लॉक करने और वापसी को कम करने के लिए मोबाइल स्टॉप-लॉस रणनीति को जोड़ा जा सकता है। साथ ही, पैरामीटर सेटिंग को अनुकूलित किया जा सकता है, संकेतक विलंबता को कम किया जा सकता है, बाजार में परिवर्तन के लिए रणनीति की संवेदनशीलता को बढ़ाया जा सकता है। इसके अलावा, बुनियादी निर्णय संकेतकों को और अधिक बढ़ाया जा सकता है, सटीकता में सुधार किया जा सकता है। यदि पैरामीटर गतिशील अनुकूलन को लागू करने के लिए मशीन सीखने की विधि लागू की जा सकती है, तो रणनीति की स्थिरता में भी काफी सुधार होगा।
इस रणनीति में प्रवृत्ति की दिशा का आकलन करने के लिए कई तरह के संकेतक शामिल हैं, प्रवृत्ति को ट्रैक करने की अवधारणा को अपनाया गया है, जिसका उद्देश्य निर्णय की सटीकता में सुधार करना और मुनाफे की संभावना बढ़ाना है। रणनीति में संकेतक संयोजन निर्णय है, प्रवृत्ति पर नज़र रखने पर जोर देना, मूल बातें शामिल करना आदि फायदे हैं, लेकिन गलतफहमी के समय, विलंबता, वापसी नियंत्रण की कमी जैसी समस्याएं भी हैं। भविष्य में, अनुकूलन पैरामीटर सेट करके, रोकथाम की रणनीति को बेहतर बनाने, मूलभूत संकेतकों को बढ़ाने आदि के माध्यम से सुधार किया जा सकता है, ताकि रणनीति वास्तविक अनुप्रयोगों में बेहतर प्रभाव प्राप्त कर सके।
/*backtest
start: 2023-11-08 00:00:00
end: 2023-11-15 00:00:00
period: 1m
basePeriod: 1m
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/
// © RolandoSantos
//@version=4
strategy(title = "VWAP Candles Strategy", overlay=true, shorttitle = "VWAP Cndl", default_qty_type=strategy.cash, default_qty_value=10000, initial_capital=10000)
//Make inputs that set the take profit %
longProfitPerc = input(title="Take Long Profit % ", minval=0.0, step=0.1, defval=0.3) / 100
shortProfitPerc = input(title="Take Short Profit % ", minval=0.0, step=0.1, defval=0.95) / 100
tp = input(100, "Take Profit % QTY (How much profit you want to take after take profit target is triggered)")
// Figure out take profit price
longExitPrice = strategy.position_avg_price * (1 + longProfitPerc)
shortExitPrice = strategy.position_avg_price * (1 - shortProfitPerc)
//Use NYSE for Copp Curve entries and exits//
security = input("", title="Change this if you want to see Copp Curve calculated for current ticker. All Copp Curve calculations are base on NYSE Composite")
ticker = security(security,"", close)
///Copp Curve////
period_ = input(21, title="Length", minval=1)
isCentered = input(false, title="Centered")
barsback = period_/2 + 1
ma = sma(close, period_)
dpo = isCentered ? close[barsback] - ma : close - ma[barsback]
instructions =input(title="Standard Copp settings are (10, 14, 11) however, DOUBLE these lengths as alternate settings to (20,28,22) and you will find it may produce better results, but less trades", defval="-")
wmaLength = input(title="WMA Length (Experiment changing this to longer lengths for less trades, but higher win %)", type=input.integer, defval=20)
longRoCLength = input(title="Long RoC Length", type=input.integer, defval=28)
shortRoCLength = input(title="Short RoC Length", type=input.integer, defval=22)
source = ticker
curve = wma(roc(source, longRoCLength) + roc(source, shortRoCLength), wmaLength)
//////////// QQE////////////QQE///////////////////QQE////////////////////////
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © KivancOzbilgic
//@version=4
src=input(close)
length = input(25,"RSI Length", minval=1)
SSF=input(9, "SF RSI SMoothing Factor", minval=1)
showsignals = input(title="Show Crossing Signals?", type=input.bool, defval=true)
highlighting = input(title="Highlighter On/Off ?", type=input.bool, defval=true)
RSII=ema(rsi(src,length),SSF)
TR=abs(RSII-RSII[1])
wwalpha = 1/ length
WWMA = 0.0
WWMA := wwalpha*TR + (1-wwalpha)*nz(WWMA[1])
ATRRSI=0.0
ATRRSI := wwalpha*WWMA + (1-wwalpha)*nz(ATRRSI[1])
QQEF=ema(rsi(src,length),SSF)
QUP=QQEF+ATRRSI*4.236
QDN=QQEF-ATRRSI*4.236
QQES=0.0
QQES:=QUP<nz(QQES[1]) ? QUP : QQEF>nz(QQES[1]) and QQEF[1]<nz(QQES[1]) ? QDN : QDN>nz(QQES[1]) ? QDN : QQEF<nz(QQES[1]) and QQEF[1]>nz(QQES[1]) ? QUP : nz(QQES[1])
//QQF=plot(QQEF,"FAST",color.maroon,2)
//QQS=plot(QQES,"SLOW",color=color.blue, linewidth=1)
buySignalr = crossover(QQEF, QQES)
sellSignalr = crossunder(QQEF, QQES)
buyr = QQEF > QQES
////QQE////////////////QQE/////////////////QQE/////////////////
//////////////LSMA//////////////////////////
// LSMA 1 Settings & Plot
lsma1Length = input(100, minval=1, title="LSMA 1")
lsma1Offset = input(title="LSMA 1 Offset", type=input.integer, defval=0)
lsma1Source = input(close, title="LSMA 1 Source")
lsma1 = linreg(lsma1Source, lsma1Length, lsma1Offset)
lsma1_std_dev = stdev(abs(lsma1[1] - lsma1), lsma1Length)
//plot(lsma1, color=(lsma1 > lsma1[1] ? color.yellow : color.blue), title="LSMA 1", linewidth=2, transp=0)
////////////LSMA///////////////////
//////////////////ADX////////////////////
len = input(14)
th = input(20)
TrueRange = max(max(high-low, abs(high-nz(close[1]))), abs(low-nz(close[1])))
DirectionalMovementPlus = high-nz(high[1]) > nz(low[1])-low ? max(high-nz(high[1]), 0): 0
DirectionalMovementMinus = nz(low[1])-low > high-nz(high[1]) ? max(nz(low[1])-low, 0): 0
SmoothedTrueRange = 0.0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1])/len) + TrueRange
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1])/len) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus = 0.0
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1])/len) + DirectionalMovementMinus
DIPlus = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIMinus = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = abs(DIPlus-DIMinus) / (DIPlus+DIMinus)*100
ADX = sma(DX, len)
///////////////////ADX/////////////////////
/////////////sqz momentum/////////////////////////
//
// @author LazyBear & ChrisMoody complied by GIS_ABC
//
lengthBB = input(20, title="BB Length")
mult = input(2.0,title="BB MultFactor")
lengthKC=input(20, title="KC Length")
multKC = input(1.5, title="KC MultFactor")
useTrueRange = input(true, title="Use TrueRange (KC)")
// Calculate BB
sourceBB = close
basis = sma(sourceBB, lengthBB)
dev = multKC * stdev(source, lengthBB)
upperBB = basis + dev
lowerBB = basis - dev
// Calculate KC
maKC = sma(sourceBB, lengthKC)
rangeKC = useTrueRange ? tr : (high - low)
rangema = sma(rangeKC, lengthKC)
upperKC = maKC + rangema * multKC
lowerKC = maKC - rangema * multKC
sqzOn = (lowerBB > lowerKC) and (upperBB < upperKC)
sqzOff = (lowerBB < lowerKC) and (upperBB > upperKC)
noSqz = (sqzOn == false) and (sqzOff == false)
val = linreg(source - avg(avg(highest(high, lengthKC), lowest(low, lengthKC)),sma(close,lengthKC)),lengthKC,0)
////////////////////////////
/////// RSI on EMA/////////////////
lenrsi = input(13, minval=1, title="Length")
srcrsi = linreg(hlc3,100,0)
up = rma(max(change(srcrsi), 0), lenrsi)
down = rma(-min(change(srcrsi), 0), lenrsi)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsicolor = rsi > rsi[1] ? color.green : color.red
//plot(rsi,color = rsicolor)
//hline(20,color=color.green)
//hline(80,color=color.red)
vwaprsi = rsi(vwap(hlc3),13)
vwaprsicolor = vwaprsi > vwaprsi[1] ? color.blue : color.yellow
emarsi = ema(rsi,13)
emarsicolor = emarsi > emarsi[1] ? color.green : color.red
//plot(emarsi,color=emarsicolor)
//plot(vwaprsi,color=vwaprsicolor)
/////// RSI on VWMA/////////////////
lenrsiv = input(23, minval=1, title="Length RSI VWMA")
srcrsiv = vwma(linreg(close,23,0),23)
upv = rma(max(change(srcrsiv), 0), lenrsiv)
downv = rma(-min(change(srcrsiv), 0), lenrsiv)
rsiv = downv == 0 ? 100 : upv == 0 ? 0 : 100 - (100 / (1 + upv / downv))
rsicolorv = rsiv > rsiv[1] ? color.green : color.red
/////////////////////////////////////
/////////////////////////////////////
////////////////coral trend////////////////////
//
// @author LazyBear
// List of all my indicators:
// https://docs.google.com/document/d/15AGCufJZ8CIUvwFJ9W-IKns88gkWOKBCvByMEvm5MLo/edit?usp=sharing
//
//study(title="Coral Trend Indicator [LazyBear]", shorttitle="CTI_LB", overlay=true)
srcCT=close
i1 = 1.0
i2 = 1.0
i3 = 1.0
i4 = 1.0
i5 = 1.0
i6 = 1.0
sm =input(21, title="Smoothing Period")
cd = input(0.4, title="Constant D")
ebc=input(false, title="Color Bars")
ribm=input(false, title="Ribbon Mode")
di = (sm - 1.0) / 2.0 + 1.0
c1 = 2 / (di + 1.0)
c2 = 1 - c1
c3 = 3.0 * (cd * cd + cd * cd * cd)
c4 = -3.0 * (2.0 * cd * cd + cd + cd * cd * cd)
c5 = 3.0 * cd + 1.0 + cd * cd * cd + 3.0 * cd * cd
i1 := c1*srcCT + c2*nz(i1[1])
i2 := c1*i1 + c2*nz(i2[1])
i3 := c1*i2 + c2*nz(i3[1])
i4 := c1*i3 + c2*nz(i4[1])
i5 := c1*i4 + c2*nz(i5[1])
i6 := c1*i5 + c2*nz(i6[1])
bfr = -cd*cd*cd*i6 + c3*(i5) + c4*(i4) + c5*(i3)
// --------------------------------------------------------------------------
// For the Pinescript coders: Determining trend based on the mintick step.
// --------------------------------------------------------------------------
//bfrC = bfr - nz(bfr[1]) > syminfo.mintick ? green : bfr - nz(bfr[1]) < syminfo.mintick ? red : blue
//bfrC = bfr > nz(bfr[1]) ? green : bfr < nz(bfr[1]) ? red : blue
//tc=ebc?gray:bfrC
//plot(ribm?na:bfr, title="Trend", linewidth=3)
//bgcolor(ribm?bfrC:na, transp=50)
//barcolor(ebc?bfrC:na)
////////////////////////////////////////////////////////////////
///////////////////VWAP///////////////////
//------------------------------------------------
//------------------------------------------------
NormalVwap=vwap(hlc3)
H = vwap(high)
L = vwap(low)
O = vwap(open)
C = vwap(close)
left = 30
left_low = lowest(left)
left_high = highest(left)
newlow = low <= left_low
newhigh = high >= left_high
q = barssince(newlow)
w = barssince(newhigh)
col2 = q < w ? #8B3A3A : #9CBA7F
col2b=O > C?color.red:color.lime
AVGHL=avg(H,L)
AVGOC=avg(O,C)
col=AVGHL>AVGOC?color.lime:color.red
col3=open > AVGOC?color.lime:color.red
//plotcandle(O,H,L,C,color=col2b)
//plot(H, title="VWAP", color=red)
//plot(L, title="VWAP", color=lime)
//plot(O, title="VWAP", color=blue)
//plot(C, title="VWAP", color=black)
//plot(NormalVwap, color=col2b)
/////////////////////////////////////////////////////////////////////////////
///Trade Conditions///
t = time(timeframe.period, "0930-1500")
long = vwaprsi > vwaprsi[1] and rsi>rsi[1] and vwaprsi < 20 //vwaprsi > 98 and rsi > 50 and rsi[1] < rsi and rsi[1] < rsi[2] //crossover(rsi,20)//O<C and O > linreg(hlc3,100,0) and linreg(hlc3,100,0) > linreg(hlc3,100,0)[1] and AVGHL>AVGOC and t //O < C and close > vwap(hlc3) and ADX > ADX[1] //and val > nz(val[1]) and close > vwap(hlc3) and open > sma(close,23) and close > vwap(hlc3) and t //and rsi > rsi[1] and open > ema(close,13) and open > bfr and bfr > bfr[1]
close_long = crossover(vwaprsi,99.8) //C < O // linreg(hlc3,100,0) and linreg(hlc3,100,0) < linreg(hlc3,100,0)[1] //O > C and val < nz(val[1]) // and close < vwap(hlc3)
close_short = rsiv > rsiv[1] and rsiv[2] > rsiv[1]//vwaprsi > vwaprsi[1] or rsi > rsi[1] // vwaprsi > 99 and rsi > 99 and rsi > rsi[1] and vwaprsi > vwaprsi[1]//vwaprsi > vwaprsi[1] and rsi>rsi[1] and vwaprsi < 20 //vwaprsi > 98 and rsi > 50 and rsi[1] < rsi and rsi[1] < rsi[2] //crossover(rsi,20)//O<C and O > linreg(hlc3,100,0) and linreg(hlc3,100,0) > linreg(hlc3,100,0)[1] and AVGHL>AVGOC and t //O < C and close > vwap(hlc3) and ADX > ADX[1] //and val > nz(val[1]) and close > vwap(hlc3) and open > sma(close,23) and close > vwap(hlc3) and t //and rsi > rsi[1] and open > ema(close,13) and open > bfr and bfr > bfr[1]
short = rsiv > 95 and rsiv < rsiv[1] and rsiv[2] < rsiv[1] //vwaprsi < 1 and rsi < 1 and rsi < rsi[1] and vwaprsi < vwaprsi[1] and t //crossover(vwaprsi,99.8) //C < O // linreg(hlc3,100,0) and linreg(hlc3,100,0) < linreg(hlc3,100,0)[1] //O > C and val < nz(val[1]) // and close < vwap(hlc3)
//long = vwaprsi > vwaprsi[1] and emarsi > emarsi[1] and emarsi[2] > emarsi[1] and ADX > 25//O<C and O > linreg(hlc3,100,0) and linreg(hlc3,100,0) > linreg(hlc3,100,0)[1] and AVGHL>AVGOC and t //O < C and close > vwap(hlc3) and ADX > ADX[1] //and val > nz(val[1]) and close > vwap(hlc3) and open > sma(close,23) and close > vwap(hlc3) and t //and rsi > rsi[1] and open > ema(close,13) and open > bfr and bfr > bfr[1]
//close_long = vwaprsi < vwaprsi[1] or emarsi < emarsi[1]//C < O // linreg(hlc3,100,0) and linreg(hlc3,100,0) < linreg(hlc3,100,0)[1] //O > C and val < nz(val[1]) // and close < vwap(hlc3)
//close_long = O>C or lsma1 < H // or O > linreg(hlc3,100,0) //and linreg(hlc3,100,0) > linreg(hlc3,100,0)[1] and AVGHL>AVGOC and t //O < C and close > vwap(hlc3) and ADX > ADX[1] //and val > nz(val[1]) and close > vwap(hlc3) and open > sma(close,23) and close > vwap(hlc3) and t //and rsi > rsi[1] and open > ema(close,13) and open > bfr and bfr > bfr[1]
//long = rsi > rsi[1] and rsi[1] >rsi[2] and lsma1 > lsma1[1] and bfr > bfr[1] and O<C and lsma1 > L and close > close[1] and ADX > ADX[1] and ADX[1] > ADX[2] and ADX > 20 and rsi > rsi[1] and t // linreg(hlc3,100,0) and linreg(hlc3,100,0) < linreg(hlc3,100,0)[1] //O > C and val < nz(val[1]) // and close < vwap(hlc3)
//close_short = O<C or lsma1 > H // or O > linreg(hlc3,100,0) //and linreg(hlc3,100,0) > linreg(hlc3,100,0)[1] and AVGHL>AVGOC and t //O < C and close > vwap(hlc3) and ADX > ADX[1] //and val > nz(val[1]) and close > vwap(hlc3) and open > sma(close,23) and close > vwap(hlc3) and t //and rsi > rsi[1] and open > ema(close,13) and open > bfr and bfr > bfr[1]
//short = rsi < rsi[1] and rsi[1] <rsi[2] and lsma1 < lsma1[1] and bfr < bfr[1] and O>C and lsma1 < L and close < close[1] and ADX > ADX[1] and ADX[1] > ADX[2] and ADX > 20 and rsi < rsi[1] and t // linreg(hlc3,100,0) and linreg(hlc3,100,0) < linreg(hlc3,100,0)[1] //O > C and val < nz(val[1]) // and close < vwap(hlc3)
/// Start date
startDate = input(title="Start Date", defval=1, minval=1, maxval=31)
startMonth = input(title="Start Month", defval=1, minval=1, maxval=12)
startYear = input(title="Start Year", defval=2021, minval=1800, maxval=2100)
// See if this bar's time happened on/after start date
afterStartDate = true
///Entries and Exits//
if (long and afterStartDate)
strategy.entry("Long", strategy.long, comment = "Open Long")
// strategy.close("Short", strategy.short,qty_percent=100, comment = "close Short")
if (short and afterStartDate)
strategy.entry("Short", strategy.short, comment = "Open Short")
if (close_long and afterStartDate )
strategy.close("Long", strategy.long, qty_percent=100, comment="close Long")
// strategy.entry("Short", strategy.short, comment="Open Short")
if (close_short and afterStartDate )
strategy.close("Short", strategy.short, qty_percent=100, comment="close Long")
if ( hour(time) == 15 and minute(time) > 15 )
strategy.close_all()
//Submit exit orders based on take profit price
if (strategy.position_size > 0 and afterStartDate)
strategy.exit(id="Long", qty_percent=tp, limit=longExitPrice)
if (strategy.position_size < 0 and afterStartDate)
strategy.exit(id="Short", qty_percent=tp, limit=shortExitPrice)