Tài nguyên đang được tải lên... tải...

Chiến lược giao dịch số lượng đa chỉ số năng động

Tác giả:ChaoZhang, Ngày: 2024-02-04 14:42:05
Tags:

Tổng quan

Chiến lược này sử dụng các tín hiệu kết hợp của nhiều chỉ số kỹ thuật để giao dịch động các tài sản cơ bản như cổ phiếu và tiền điện tử. Chiến lược có thể tự động xác định xu hướng thị trường và theo dõi chúng. Ngoài ra, cơ chế dừng lỗ được kết hợp để kiểm soát rủi ro.

Nguyên tắc

Chiến lược này chủ yếu sử dụng các đường trung bình động, chỉ số sức mạnh tương đối (RSI), phạm vi thực tế trung bình (ATR) và chỉ số chuyển động theo hướng (ADX) để tạo ra các tín hiệu giao dịch.

Đặc biệt, nó đầu tiên áp dụng đường chéo trung bình động kép để tạo ra tín hiệu. Đường nhanh có chiều dài 10 ngày và đường chậm có chiều dài 50 ngày. Đường chéo vàng (đường nhanh vượt qua đường chậm từ dưới) tạo ra tín hiệu mua trong khi đường chéo chết tạo ra tín hiệu bán. Hệ thống này có thể xác định hiệu quả sự đảo ngược trong xu hướng dài hạn.

Trên đỉnh của hai MAs, RSI được giới thiệu để xác nhận các tín hiệu xu hướng và tránh đột phá sai. RSI đánh giá sức mạnh thị trường bằng sự khác biệt giữa đường nhanh và đường chậm. Khi RSI vượt trên 30, tín hiệu mua được tạo ra. Khi vượt dưới 70, tín hiệu bán được tạo ra.

Ngoài ra, ATR được sử dụng để tự động điều chỉnh mức dừng lỗ. ATR có thể phản ánh hiệu quả sự biến động của thị trường. Khi biến động tăng, stop loss rộng hơn sẽ được thiết lập để giảm xác suất bị dừng.

Cuối cùng, ADX đo sức mạnh của xu hướng. ADX sử dụng sự khác biệt giữa chỉ số tích cực DI + và chỉ số tiêu cực DI- để đo sức mạnh của xu hướng. Chỉ khi ADX phá vỡ trên 20, xu hướng được coi là đã được thiết lập và các tín hiệu giao dịch thực tế được tạo ra.

Bằng cách kết hợp các tín hiệu từ nhiều chỉ số, chiến lược có thể thận trọng hơn trong việc gửi tín hiệu giao dịch, tránh sự can thiệp từ các tín hiệu sai và do đó đạt được tỷ lệ thắng cao hơn.

Ưu điểm

Những lợi thế của chiến lược này bao gồm:

Kết hợp nhiều chỉ số cải thiện độ chính xác quyết định

Sự kết hợp của MA, RSI, ATR, ADX và nhiều hơn nữa có thể cải thiện độ chính xác và tránh các phán đoán sai do chỉ số duy nhất.

Rủi ro kiểm soát điều chỉnh dừng lỗ tự động

Điều chỉnh dừng lỗ dựa trên sự biến động của thị trường có thể làm giảm xác suất dừng lại và quản lý rủi ro hiệu quả.

Đánh giá sức mạnh xu hướng tránh giao dịch chống lại xu hướng

Bằng cách đánh giá sức mạnh xu hướng với ADX trước khi giao dịch thực tế, tổn thất từ giao dịch chống lại xu hướng có thể được giảm.

Không gian điều chỉnh tham số lớn

Các thông số như chiều dài MA, chiều dài RSI, thời gian ATR và thời gian ADX đều có thể được điều chỉnh và tối ưu hóa cho các thị trường khác nhau.

Bảo vệ lợi nhuận dài hạn

Xác định xu hướng dài hạn bằng cách sử dụng hệ thống MA nhanh và chậm và giảm tiếng ồn ngắn hạn với các chỉ số như RSI, giữ xu hướng dài hạn trở nên có thể cho lợi nhuận cao hơn.

Rủi ro và giải pháp

Ngoài ra còn có một số rủi ro liên quan đến chiến lược này:

Khó khăn tối ưu hóa tham số

Nhiều thông số hơn có nghĩa là khó khăn hơn trong tối ưu hóa. Các bộ thông số không phù hợp có thể làm suy giảm hiệu suất chiến lược. Kiểm tra ngược và điều chỉnh thông số thích hợp hơn có thể giảm thiểu rủi ro này.

Nguy cơ thất bại của chỉ số

Tất cả các chỉ số kỹ thuật đều có các trạng thái thị trường áp dụng. Khi thị trường đi vào các trạng thái đặc biệt, các chỉ số được sử dụng có thể thất bại đồng thời. Những rủi ro từ các sự kiện BLACK SWAN như vậy cần chú ý.

Rủi ro mất mát không giới hạn do mua bán ngắn

Chiến lược này cho phép giao dịch ngắn. Các vị trí ngắn vốn có rủi ro thua lỗ không giới hạn. Điều này có thể được giảm bằng cách thiết lập stop loss thích hợp.

Rủi ro đảo ngược xu hướng

Các chỉ số không thể phản ứng ngay lập tức với sự đảo ngược. Các vị trí hướng sai thường gây ra tổn thất trong khi đảo ngược. Việc rút ngắn các tham số của một số chỉ số có thể cải thiện độ nhạy.

Tối ưu hóa

Có chỗ cho việc tối ưu hóa thêm:

Trọng lượng chỉ số thích nghi

Phân tích mối tương quan giữa các chỉ số / tình trạng thị trường và các cơ chế thiết kế để điều chỉnh động các trọng số chỉ số dựa trên các điều kiện thị trường thay đổi để cải thiện quyết định.

Tăng cường bằng học sâu

Sử dụng các mô hình học sâu để dự đoán hướng chuyển động giá và tăng cường hệ thống dựa trên quy tắc để cải thiện độ chính xác.

Điều chỉnh tham số thích nghi

Thiết kế các mô-đun điều chỉnh thích nghi cho các thông số chỉ số dựa trên dữ liệu lịch sử cửa sổ trượt để chiến lược có thể thích nghi tốt hơn.

Bao gồm phân tích thời gian biến

Tích hợp phân tích thời gian biến thể như Lý thuyết sóng Elliott để giúp đánh giá xu hướng trung dài hạn và cải thiện lợi nhuận.

Kết luận

Tóm lại, chiến lược này tích hợp MA, RSI, ATR, ADX và nhiều hơn nữa vào một hệ thống tương đối toàn diện, có thể xác định xu hướng dài hạn thông qua hệ thống MA và giảm nhiễu nhiễu với các chỉ số ngắn hạn như RSI. Ngoài ra, có không gian tối ưu hóa lớn để cải thiện hiệu suất. Chiến lược cải thiện quyết định bằng cách kết hợp các chỉ số và kiểm soát rủi ro. Nó xứng đáng nghiên cứu và áp dụng thêm.

/*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

Thêm nữa

2019 FMZ - Tất cả các quyền được bảo lưu