ChaoZhang
개요
이 전략은 다양한 기술 지표의 조합 신호를 사용하여 주식, 디지털 통화 등에 대한 자산의 동적 거래를 구현한다. 전략은 자동으로 시장 추세를 식별하고 추세를 추적 할 수 있다. 동시에 전략은 위험을 제어하기 위해 손실 제도를 추가했다.
전략 원칙
이 전략은 주로 이동 평균, 상대적으로 약한 지표 ((RSI), 평균 실제 파도 ((ATR) 및 방향 운동 지표 ((ADX) 와 같은 여러 지표를 사용하여 지표의 조합을 통해 거래 신호를 생성합니다.
구체적으로, 이 전략은 먼저 쌍 이동 평균을 사용하여 금 포크 사다리 신호를 형성한다. 빠른 선의 길이는 10일이고, 느린 선의 길이는 50일이다. 빠른 선이 하향에서 느린 선을 뚫을 때, 구매 신호를 생성한다. 빠른 선이 상향에서 하향으로 느린 선을 뚫을 때, 판매 신호를 생성한다. 이 쌍 이동 평균 시스템은 시장에서 긴 선의 경향의 전환을 효과적으로 식별 할 수 있다.
이중 이동 평균을 기반으로, 전략은 또한 트렌드 신호를 확인하기 위해 RSI 지표를 도입하여 가짜 돌파구를 방지합니다. RSI는 빠른 라인과 느린 라인의 차수를 통해 시장의 힘을 판단합니다. Length는 14입니다. RSI가 30을 넘으면 구매 신호를 생성하고 70을 넘으면 판매 신호를 생성합니다.
또한, 전략은 ATR 지표를 사용하여 자동으로 중지 지점을 조정한다. ATR 지표는 시장의 변동 정도를 효과적으로 반영할 수 있다. 시장의 변동이 커지면 전략은 중지 지점을 좀 더 넓게 설정하여 중단 될 가능성을 줄인다.
마지막으로, 전략은 ADX 지표로 트렌드의 강도를 판단한다. ADX는 긍정적인 지표 DI+와 부정적인 지표 DI-의 차이를 통해 트렌드의 강도를 판단한다. ADX 값이 20을 넘으면 트렌드가 구축되었다고 생각하며 실제 거래 신호가 발생한다.
여러 지표의 조합을 통해, 전략은 거래 신호를 발송할 때 더 신중하게 할 수 있으며, 시장의 가짜 신호에 속지 않도록 할 수 있으며, 이로 인해 더 높은 승률을 얻을 수 있다.
전략적 이점
이 전략은 다음과 같은 장점을 가지고 있습니다.
- 다양한 지표 포트폴리오, 통합 시장 판단, 의사 결정 정확성 향상
평균선, RSI, ATR, ADX 등의 여러 지표를 조합하여 거래 의사 결정의 정확성을 높일 수 있으며 단일 지표로 인한 잘못된 판단을 피할 수 있습니다.
- 자동으로 스톱을 조정하고 위험을 통제합니다.
시장의 변동성에 따라 자동으로 스톱로스를 조정하여 스톱로스가 유발되는 확률을 줄이고 거래 위험을 효과적으로 제어 할 수 있습니다.
- 트렌드 강도를 판단하고 역작업을 줄여라
ADX 지표로 트렌드 강도를 판단한 후 실제 거래하면 역경에 따른 손실을 줄일 수 있다.
- 변수 최적화 공간이 넓다
이 전략의 평균선 길이, RSI 길이, ATR 주기, ADX 주기 등의 파라미터는 다른 시장에 따라 조정 및 최적화 할 수 있습니다.
- 장선 수익을 보호하는 것
빠른 속도 평균 선 체계로 긴 선의 추세를 판단하고, RSI와 같은 지표와 함께 짧은 선의 소음의 영향을 줄여, 추세에서 긴 선을 보유하여 더 높은 수익을 얻을 수 있습니다.
위험과 대책
이 전략에는 몇 가지 위험도 있습니다. 주요 위험은 다음과 같습니다.
- 매개변수 최적화 위험
다중변수조합은 최적화를 어렵게 하고, 부적절한 변수조합은 전략효과의 저하를 초래할 수 있다. 이 위험은 보다 충분한 회전과 변수조정을 통해 감소시킬 수 있다.
- 지표의 실패 위험
기술 지표는 모두 적용 가능한 시장 상태가 있다. 시장이 특별한 상태로 들어가면 전략에 관련된 지표는 동시에 무효가 될 수 있다. 이러한 BLACK SWAN 사건으로 인한 위험은 주의해야 한다.
- 적립금 손실 위험
전략에서 공상 거래를 허용한다. 공상 거래 자체는 무제한의 손실 위험을 가지고 있다. 이 위험을 스톱 로스를 설정하여 줄일 수 있다.
- 역전 위험
트렌드 반전시 지표 신호는 신속하게 반응할 수 없으며, 이때 반전 손실이 발생할 수 있다. 일부 지표 파라미터를 적절히 줄여 민감도를 높일 수 있다.
더 나은 생각
이 전략에는 더 많은 최적화를 위한 여지가 있습니다. 주요 최적화 아이디어는 다음과 같습니다.
- 적응에 대한 지표의 무게를 높여라
다양한 지표와 시장 상태의 연관성을 분석함으로써 각 지표의 무게를 동적으로 조정하는 메커니즘을 설계하여 다양한 시장 환경에서 의사 결정의 효과를 높일 수 있습니다.
- 더 많은 딥러닝 모델 지원
딥러닝과 같은 모델을 사용하여 가격 변동 방향을 예측하고, 전략적 의사 결정의 정확성을 높이기 위해 의사 결정 규칙을 인공적으로 설계합니다.
- 최적화 매개 변수가 적응
슬라이드 창에 대한 역사 데이터에 대한 자동 변수 최적화 모듈을 설계하여 지표 변수의 동적 조정을 구현하여 전략을 시장 변화에 더 잘 적응시킵니다.
- 길이가 변하는 주기 분석을 도입한다
파동 이론과 같은 변동주기 분석 방법을 추가하여 트렌드 중 긴 선의 움직임을 판단하고 포지션의 수익률을 높인다.
요약하다
이 전략은 이동 평균선, RSI, ATR, ADX 등 여러 지표를 통합하여 더 긴 선의 추세를 평준화 시스템으로 판단 할 수 있으며, RSI와 같은 단기 주기 지표를 통해 노이즈 간섭을 줄일 수 있습니다. 또한 이 전략은 더 나은 성과를 얻을 수 있습니다.
전략 소스 코드
/*backtest
start: 2023-01-28 00:00:00
end: 2024-02-03 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This source code to my testing
// © sgb
//@version=5
strategy(title='Soren test 2', overlay=true, initial_capital=100, pyramiding=1, calc_on_order_fills=true, calc_on_every_tick=true, default_qty_type=strategy.percent_of_equity, default_qty_value=50, commission_value=0.04)
//SOURCE =============================================================================================================================================================================================================================================================================================================
src = input(open)
// INPUTS ============================================================================================================================================================================================================================================================================================================
//ADX --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ADX_options = input.string('MASANAKAMURA', title='Adx Type', options=['CLASSIC', 'MASANAKAMURA'], group='ADX')
ADX_len = input.int(38, title='Adx lenght', minval=1, group='ADX')
th = input.float(23, title='Adx Treshold', minval=0, step=0.5, group='ADX')
// Volume ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
volume_f = input.float(1.2, title='Volume mult.', minval=0, step=0.1, group='Volume')
sma_length = input.int(35, title='Volume lenght', minval=1, group='Volume')
//RSI----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
len_3 = input.int(25, title='RSI lenght', group='Relative Strenght Indeks')
src_3 = input.source(low, title='RSI Source', group='Relative Strenght Indeks')
RSI_VWAP_length = input(25, title='Rsi vwap lenght')
// Range Filter ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
per_ = input.int(26, title='SAMPLING PERIOD', minval=1, group='Range Filter')
mult = input.float(2.3, title='RANGE MULTIPLIER', minval=0.1, step=0.1, group='Range Filter')
// Cloud --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
len = input.int(1, title='Cloud Length', group='Cloud')
//RMI ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
RMI_len = input.int(26, title='Rmi Lenght', minval=1, group='Relative Momentum Index')
mom = input.int(17, title='Rmi Momentum', minval=1, group='Relative Momentum Index')
RMI_os = input.int(33, title='Rmi oversold', minval=0, group='Relative Momentum Index')
RMI_ob = input.int(68, title='Rmi overbought', minval=0, group='Relative Momentum Index')
// Indicators Calculations ========================================================================================================================================================================================================================================================================================================
// Range Filter ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool L_RF = na
var bool S_RF = na
Range_filter(_src, _per_, _mult) =>
var float _upward = 0.0
var float _downward = 0.0
wper = _per_ * 2 - 1
avrng = ta.ema(math.abs(_src - _src[1]), _per_)
_smoothrng = ta.ema(avrng, wper) * _mult
_filt = _src
_filt := _src > nz(_filt[1]) ? _src - _smoothrng < nz(_filt[1]) ? nz(_filt[1]) : _src - _smoothrng : _src + _smoothrng > nz(_filt[1]) ? nz(_filt[1]) : _src + _smoothrng
_upward := _filt > _filt[1] ? nz(_upward[1]) + 1 : _filt < _filt[1] ? 0 : nz(_upward[1])
_downward := _filt < _filt[1] ? nz(_downward[1]) + 1 : _filt > _filt[1] ? 0 : nz(_downward[1])
[_smoothrng, _filt, _upward, _downward]
[smoothrng, filt, upward, downward] = Range_filter(src, per_, mult)
hband = filt + smoothrng
lband = filt - smoothrng
L_RF := high > hband and upward > 0
S_RF := low < lband and downward > 0
//ADX-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
calcADX(_len) =>
up = ta.change(high)
down = -ta.change(low)
plusDM = na(up) ? na : up > down and up > 0 ? up : 0
minusDM = na(down) ? na : down > up and down > 0 ? down : 0
truerange = ta.rma(ta.tr, _len)
_plus = fixnan(100 * ta.rma(plusDM, _len) / truerange)
_minus = fixnan(100 * ta.rma(minusDM, _len) / truerange)
sum = _plus + _minus
_adx = 100 * ta.rma(math.abs(_plus - _minus) / (sum == 0 ? 1 : sum), _len)
[_plus, _minus, _adx]
calcADX_Masanakamura(_len) =>
SmoothedTrueRange = 0.0
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementMinus = 0.0
TrueRange = math.max(math.max(high - low, math.abs(high - nz(close[1]))), math.abs(low - nz(close[1])))
DirectionalMovementPlus = high - nz(high[1]) > nz(low[1]) - low ? math.max(high - nz(high[1]), 0) : 0
DirectionalMovementMinus = nz(low[1]) - low > high - nz(high[1]) ? math.max(nz(low[1]) - low, 0) : 0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - nz(SmoothedTrueRange[1]) / _len + TrueRange
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - nz(SmoothedDirectionalMovementPlus[1]) / _len + DirectionalMovementPlus
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - nz(SmoothedDirectionalMovementMinus[1]) / _len + DirectionalMovementMinus
DIP = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIM = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = math.abs(DIP - DIM) / (DIP + DIM) * 100
adx = ta.sma(DX, _len)
[DIP, DIM, adx]
[DIPlusC, DIMinusC, ADXC] = calcADX(ADX_len)
[DIPlusM, DIMinusM, ADXM] = calcADX_Masanakamura(ADX_len)
DIPlus = ADX_options == 'CLASSIC' ? DIPlusC : DIPlusM
DIMinus = ADX_options == 'CLASSIC' ? DIMinusC : DIMinusM
ADX = ADX_options == 'CLASSIC' ? ADXC : ADXM
L_adx = DIPlus > DIMinus and ADX > th
S_adx = DIPlus < DIMinus and ADX > th
// Volume -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Volume_condt = volume > ta.sma(volume, sma_length) * volume_f
//RSI------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
up_3 = ta.rma(math.max(ta.change(src_3), 0), len_3)
down_3 = ta.rma(-math.min(ta.change(src_3), 0), len_3)
rsi_3 = down_3 == 0 ? 100 : up_3 == 0 ? 0 : 100 - 100 / (1 + up_3 / down_3)
L_rsi = rsi_3 < 70
S_rsi = rsi_3 > 30
RSI_VWAP = ta.rsi(ta.vwap(close), RSI_VWAP_length)
RSI_VWAP_overSold = 13
RSI_VWAP_overBought = 68
L_VAP = ta.crossover(RSI_VWAP, RSI_VWAP_overSold)
S_VAP = ta.crossunder(RSI_VWAP, RSI_VWAP_overBought)
//Cloud --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
PI = 2 * math.asin(1)
hilbertTransform(src) =>
0.0962 * src + 0.5769 * nz(src[2]) - 0.5769 * nz(src[4]) - 0.0962 * nz(src[6])
computeComponent(src, mesaPeriodMult) =>
hilbertTransform(src) * mesaPeriodMult
computeAlpha(src, fastLimit, slowLimit) =>
mesaPeriod = 0.0
mesaPeriodMult = 0.075 * nz(mesaPeriod[1]) + 0.54
smooth = 0.0
smooth := (4 * src + 3 * nz(src[1]) + 2 * nz(src[2]) + nz(src[3])) / 10
detrender = 0.0
detrender := computeComponent(smooth, mesaPeriodMult)
I1 = nz(detrender[3])
Q1 = computeComponent(detrender, mesaPeriodMult)
jI = computeComponent(I1, mesaPeriodMult)
jQ = computeComponent(Q1, mesaPeriodMult)
I2 = 0.0
Q2 = 0.0
I2 := I1 - jQ
Q2 := Q1 + jI
I2 := 0.2 * I2 + 0.8 * nz(I2[1])
Q2 := 0.2 * Q2 + 0.8 * nz(Q2[1])
Re = I2 * nz(I2[1]) + Q2 * nz(Q2[1])
Im = I2 * nz(Q2[1]) - Q2 * nz(I2[1])
Re := 0.2 * Re + 0.8 * nz(Re[1])
Im := 0.2 * Im + 0.8 * nz(Im[1])
if Re != 0 and Im != 0
mesaPeriod := 2 * PI / math.atan(Im / Re)
mesaPeriod
if mesaPeriod > 1.5 * nz(mesaPeriod[1])
mesaPeriod := 1.5 * nz(mesaPeriod[1])
mesaPeriod
if mesaPeriod < 0.67 * nz(mesaPeriod[1])
mesaPeriod := 0.67 * nz(mesaPeriod[1])
mesaPeriod
if mesaPeriod < 6
mesaPeriod := 6
mesaPeriod
if mesaPeriod > 50
mesaPeriod := 50
mesaPeriod
mesaPeriod := 0.2 * mesaPeriod + 0.8 * nz(mesaPeriod[1])
phase = 0.0
if I1 != 0
phase := 180 / PI * math.atan(Q1 / I1)
phase
deltaPhase = nz(phase[1]) - phase
if deltaPhase < 1
deltaPhase := 1
deltaPhase
alpha = fastLimit / deltaPhase
if alpha < slowLimit
alpha := slowLimit
alpha
[alpha, alpha / 2.0]
er = math.abs(ta.change(src, len)) / math.sum(math.abs(ta.change(src)), len)
[a, b] = computeAlpha(src, er, er * 0.1)
mama = 0.0
mama := a * src + (1 - a) * nz(mama[1])
fama = 0.0
fama := b * mama + (1 - b) * nz(fama[1])
alpha = math.pow(er * (b - a) + a, 2)
kama = 0.0
kama := alpha * src + (1 - alpha) * nz(kama[1])
L_cloud = kama > kama[1]
S_cloud = kama < kama[1]
// RMI -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
RMI(len, m) =>
up = ta.ema(math.max(close - close[m], 0), len)
dn = ta.ema(math.max(close[m] - close, 0), len)
RMI = dn == 0 ? 0 : 100 - 100 / (1 + up / dn)
RMI
L_rmi = ta.crossover(RMI(RMI_len, mom), RMI_os)
S_rmi = ta.crossunder(RMI(RMI_len, mom), RMI_ob)
//STRATEGY ==========================================================================================================================================================================================================================================================================================================
L_1 = L_VAP and L_RF and not S_adx
S_1 = S_VAP and S_RF and not L_adx
L_2 = L_adx and Volume_condt and L_rsi and L_cloud
S_2 = S_adx and Volume_condt and S_rsi and S_cloud
L_3 = L_rmi and L_RF and not S_adx
S_3 = S_rmi and S_RF and not L_adx
L_basic_condt = L_1 or L_2 or L_3
S_basic_condt = S_1 or S_2 or S_3
var bool longCondition = na
var bool shortCondition = na
var float last_open_longCondition = na
var float last_open_shortCondition = na
var int last_longCondition = 0
var int last_shortCondition = 0
longCondition := L_basic_condt
shortCondition := S_basic_condt
last_open_longCondition := longCondition ? close : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close : nz(last_open_shortCondition[1])
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])
in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition
// SWAP-SL ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var int last_long_sl = na
var int last_short_sl = na
sl = input.float(2, 'Swap % period', minval=0, step=0.1, group='strategy settings')
long_sl = ta.crossunder(low, (1 - sl / 100) * last_open_longCondition) and in_longCondition and not longCondition
short_sl = ta.crossover(high, (1 + sl / 100) * last_open_shortCondition) and in_shortCondition and not shortCondition
last_long_sl := long_sl ? time : nz(last_long_sl[1])
last_short_sl := short_sl ? time : nz(last_short_sl[1])
var bool CondIni_long_sl = 0
CondIni_long_sl := long_sl ? 1 : longCondition ? -1 : nz(CondIni_long_sl[1])
var bool CondIni_short_sl = 0
CondIni_short_sl := short_sl ? 1 : shortCondition ? -1 : nz(CondIni_short_sl[1])
Final_Long_sl = long_sl and nz(CondIni_long_sl[1]) == -1 and in_longCondition and not longCondition
Final_Short_sl = short_sl and nz(CondIni_short_sl[1]) == -1 and in_shortCondition and not shortCondition
var int sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
var int sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
// RE-ENTRY ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
if longCondition or Final_Long_sl
sectionLongs += 1
sectionShorts := 0
sectionShorts
if shortCondition or Final_Short_sl
sectionLongs := 0
sectionShorts += 1
sectionShorts
var float sum_long = 0.0
var float sum_short = 0.0
if longCondition
sum_long := nz(last_open_longCondition) + nz(sum_long[1])
sum_short := 0.0
sum_short
if Final_Long_sl
sum_long := (1 - sl / 100) * last_open_longCondition + nz(sum_long[1])
sum_short := 0.0
sum_short
if shortCondition
sum_short := nz(last_open_shortCondition) + nz(sum_short[1])
sum_long := 0.0
sum_long
if Final_Short_sl
sum_long := 0.0
sum_short := (1 + sl / 100) * last_open_shortCondition + nz(sum_short[1])
sum_short
var float Position_Price = 0.0
Position_Price := nz(Position_Price[1])
Position_Price := longCondition or Final_Long_sl ? sum_long / sectionLongs : shortCondition or Final_Short_sl ? sum_short / sectionShorts : na
//TP_1 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
tp = input.float(1.2, 'Tp-1 ', minval=0, step=0.1, group='strategy settings')
long_tp = ta.crossover(high, (1 + tp / 100) * fixnan(Position_Price)) and in_longCondition and not longCondition
short_tp = ta.crossunder(low, (1 - tp / 100) * fixnan(Position_Price)) and in_shortCondition and not shortCondition
var int last_long_tp = na
var int last_short_tp = na
last_long_tp := long_tp ? time : nz(last_long_tp[1])
last_short_tp := short_tp ? time : nz(last_short_tp[1])
Final_Long_tp = long_tp and last_longCondition > nz(last_long_tp[1])
Final_Short_tp = short_tp and last_shortCondition > nz(last_short_tp[1])
fixnan_1 = fixnan(Position_Price)
ltp = Final_Long_tp ? fixnan_1 * (1 + tp / 100) : na
fixnan_2 = fixnan(Position_Price)
stp = Final_Short_tp ? fixnan_2 * (1 - tp / 100) : na
if Final_Short_tp or Final_Long_tp
sum_long := 0.0
sum_short := 0.0
sectionLongs := 0
sectionShorts := 0
sectionShorts
if Final_Long_tp
CondIni_long_sl == 1
if Final_Short_tp
CondIni_short_sl == 1
// COLORS & PLOTS --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ADX_COLOR = L_adx ? color.lime : S_adx ? color.red : color.orange
barcolor(color=ADX_COLOR)
hbandplot = plot(hband, title='RF HT', color=ADX_COLOR, transp=50)
lbandplot = plot(lband, title='RF LT', color=ADX_COLOR, transp=50)
fill(hbandplot, lbandplot, title='RF TR', color=ADX_COLOR, transp=90)
plotshape(longCondition, title='Long', style=shape.triangleup, location=location.belowbar, color=color.new(color.blue, 0), size=size.tiny)
plotshape(shortCondition, title='Short', style=shape.triangledown, location=location.abovebar, color=color.new(color.red, 0), size=size.tiny)
plot(ltp, style=plot.style_circles, linewidth=5, color=color.new(color.fuchsia, 0), editable=false)
plot(stp, style=plot.style_circles, linewidth=5, color=color.new(color.fuchsia, 0), editable=false)
//BACKTESTING--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Q = 50
SL = input.float(0.4, 'StopLoss ', minval=0, step=0.1)
strategy.entry('long', strategy.long, when=longCondition)
strategy.entry('short', strategy.short, when=shortCondition)
strategy.exit('TP', 'long', qty_percent=Q, limit=fixnan(Position_Price) * (1 + tp / 100))
strategy.exit('TP', 'short', qty_percent=Q, limit=fixnan(Position_Price) * (1 - tp / 100))
strategy.exit('SL', 'long', stop=fixnan(Position_Price) * (1 - SL / 100))
strategy.exit('SL', 'short', stop=fixnan(Position_Price) * (1 + SL / 100))
//
//
//
//
//
//
// By SGB