SSL 하이브리드 출구 화살표 양자 전략
저자:차오장, 날짜: 2023-12-06 15:54:12태그:
전반적인 설명
SSL 하이브리드 출구 화살표 양자 전략 (SSL Hybrid Exit Arrow Quant Strategy) 은 이동 평균과 최대/최저 가격 지표에 기반한 단기적인 양적 거래 전략이다. 이 전략은 QQE 지표로 필터로 입력 및 출구 지점을 결정하기 위해 SSL 하이브리드 지표의 EXIT 화살표를 활용하고 ATR 지표로 스톱 로스 및 추가 포지션을 계산한다. 이 전략은 시장 변동성에 민감하고 엄격한 위험 통제를 가진 투자자에게 적합하다.
전략 논리
이 전략은 SSL 하이브리드 지표의 EXIT 화살표를 사용하여 엔트리 포인트를 결정합니다. EXIT 화살표 위에는 EXIT 고점이 있으며, 그 아래에 EXIT 저점이 있습니다. 폐쇄 가격이 EXIT 고점을 넘을 때 판매 신호가 생성되며, 종료 가격이 EXIT 저점을 넘을 때 구매 신호가 생성됩니다.
신호 신뢰성을 향상시키기 위해 QQE 지표는 보조 필터 조건으로 도입됩니다. EXIT 화살표로 생성된 신호는 QQE 지표가 같은 방향으로 있을 때만 실행됩니다.
이 전략은 위험을 제어하기 위해 스톱 로스 및 애드온 포지션을 계산하기 위해 ATR 배수를 사용합니다. 쇼트 포지션의 스톱 로스는 클로즈 가격 + ATR × 1.8입니다. 롱 포지션의 스톱 로스는 클로즈 가격
각 부가 포지션은 자체적인 스톱 로스를 가지고 있습니다. 포지션 크기의 20%를 가진 첫 번째 랩은 스톱 로스 수준에 도달하면 스톱 로스를 멈추게 되며 나머지 포지션은 계속 유지됩니다.
장점
- EXIT 화살표에서 수익을 창출하고 적시에 스톱 로스를 통해 위험을 효과적으로 제어합니다.
- QQE 필터는 신호 정확성을 향상시킵니다.
- 더 정확한 위험 통제를 위해 시장 변동성을 기반으로 동적 스톱 로스 및 추가 포지션을 계산하기 위해 ATR 지표를 사용
- 부가형 부가 포지션을 통해 트렌드를 최대한 활용합니다.
위험성
- 수익성 있는 포지션의 부분적 스톱 손실은 나머지 포지션을 추가 스톱 손실에 노출시킬 수 있습니다. 전체 수익 취득 또는 기본 기반 스톱 손실을 고려하십시오.
- 시장 변동성에 대한 감수성의 차이점 EXIT 화살표와 QQE 사이에는 충돌 신호가 발생할 수 있습니다. 신호 충돌을 줄이기 위해 매개 변수를 조정해야합니다.
- 과도하게 공격적인 부가 포지션은 상위와 덤핑 바닥을 추구하고 있습니다. 포지션 크기는 시장 조건에 맞아야합니다.
최적화 방향
- P/B 비율, P/E 비율, 배당 수익률과 같은 기본 지표들을 포함시켜 기본 지표에 기반한 수익률을 높여야 합니다.
- QQE 매개 변수를 EXIT 화살표와 신호를 맞추도록 조정합니다.
- 다양한 시장에서 시장 정서에 따라 부가율을 줄여야 합니다.
- 최대 사용량, 위험/이익 비율 등에 기초한 최적의 매개 변수 집합을 테스트합니다.
요약
이 전략은 SSL 하이브리드 지표의 EXIT 화살표를 신호의 핵심으로 사용하고 QQE 및 ATR 지표를 필터와 스톱 로지로 사용합니다. 수익 복합화는 팩트 된 추가 포지션을 통해 달성됩니다. 단기 시장 트렌드를 추적하는 데 적합한 단기 정량 전략입니다. 전략은 인수 감축 및 위험 완화 기능을 갖추고 있지만 신호 충돌 및 상위 / 바닥을 추격하는 것과 같은 위험을 주목해야합니다. 기본 기반의 수익을 취하고 오스실레이션 시장을 결정하고 추가 비율을 줄이면서 더 신중하게 할 때 이 전략의 수익 잠재력을 더욱 확장 할 수 있습니다.
/*backtest
start: 2023-11-28 00:00:00
end: 2023-12-05 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
args: [["TradeAmount",2,358374]]
*/
//@version=4
// Strategy based on the SSL Hybrid indicator by Mihkel00
// Designed for the purpose of back testing
// Strategy:
// - Enters both long and short trades based on SSL1 crossing the baseline
// - Stop Loss calculated based on ATR multiplier
// - Take Profit calculated based on 2 ATR multipliers and exits percentage of position on TP1 and TP2
//
// Credits:
// SSL Hybrid Mihkel00 https://www.tradingview.com/u/Mihkel00/
// -------------------------------- SSL HYBRID ---------------------------------
strategy("SSL Exit Arrow Strategy", overlay=true)
show_Baseline = input(title="Show Baseline", type=input.bool, defval=true, group="SSL Hybrid Indicator Settings")
show_SSL1 = input(title="Show SSL1", type=input.bool, defval=true, group="SSL Hybrid Indicator Settings")
show_atr = input(title="Show ATR bands", type=input.bool, defval=false, group="SSL Hybrid Indicator Settings")
//ATR
atrlen = input(14, "ATR Period", group="SSL Hybrid Indicator Settings")
mult = input(1, "ATR Multi", step=0.1, group="SSL Hybrid Indicator Settings")
smoothing = input(title="ATR Smoothing", defval="WMA", options=["RMA", "SMA", "EMA", "WMA"], group="SSL Hybrid Indicator Settings")
ma_function(source, atrlen) =>
if smoothing == "RMA"
rma(source, atrlen)
else
if smoothing == "SMA"
sma(source, atrlen)
else
if smoothing == "EMA"
ema(source, atrlen)
else
wma(source, atrlen)
atr_slen = ma_function(tr(true), atrlen)
////ATR Up/Low Bands
upper_band = atr_slen * mult + close
lower_band = close - atr_slen * mult
////BASELINE / SSL1 / SSL2 / EXIT MOVING AVERAGE VALUES
maType = input(title="SSL1 / Baseline Type", type=input.string, defval="HMA", options=["SMA","EMA","DEMA","TEMA","LSMA","WMA","MF","VAMA","TMA","HMA", "JMA", "Kijun v2", "EDSMA","McGinley"], group="SSL Hybrid Indicator Settings")
len = input(title="SSL1 / Baseline Length", defval=60, group="SSL Hybrid Indicator Settings")
SSL2Type = input(title="SSL2 / Continuation Type", type=input.string, defval="JMA", options=["SMA","EMA","DEMA","TEMA","WMA","MF","VAMA","TMA","HMA", "JMA","McGinley"], group="SSL Hybrid Indicator Settings")
len2 = input(title="SSL 2 Length", defval=5, group="SSL Hybrid Indicator Settings")
//
SSL3Type = input(title="EXIT Type", type=input.string, defval="HMA", options=["DEMA","TEMA","LSMA","VAMA","TMA","HMA","JMA", "Kijun v2", "McGinley", "MF"], group="SSL Hybrid Indicator Settings")
len3 = input(title="EXIT Length", defval=15, group="SSL Hybrid Indicator Settings")
src = input(title="Source", type=input.source, defval=close, group="SSL Hybrid Indicator Settings")
//
tema(src, len) =>
ema1 = ema(src, len)
ema2 = ema(ema1, len)
ema3 = ema(ema2, len)
(3 * ema1) - (3 * ema2) + ema3
kidiv = input(defval=1,maxval=4, title="Kijun MOD Divider", group="SSL Hybrid Indicator Settings")
jurik_phase = input(title="* Jurik (JMA) Only - Phase", type=input.integer, defval=3, group="SSL Hybrid Indicator Settings")
jurik_power = input(title="* Jurik (JMA) Only - Power", type=input.integer, defval=1, group="SSL Hybrid Indicator Settings")
volatility_lookback = input(10, title="* Volatility Adjusted (VAMA) Only - Volatility lookback length", group="SSL Hybrid Indicator Settings")
//MF
beta = input(0.8,minval=0,maxval=1,step=0.1, title="Modular Filter, General Filter Only - Beta", group="SSL Hybrid Indicator Settings")
feedback = input(false, title="Modular Filter Only - Feedback", group="SSL Hybrid Indicator Settings")
z = input(0.5,title="Modular Filter Only - Feedback Weighting",step=0.1, minval=0, maxval=1, group="SSL Hybrid Indicator Settings")
//EDSMA
ssfLength = input(title="EDSMA - Super Smoother Filter Length", type=input.integer, minval=1, defval=20, group="SSL Hybrid Indicator Settings")
ssfPoles = input(title="EDSMA - Super Smoother Filter Poles", type=input.integer, defval=2, options=[2, 3], group="SSL Hybrid Indicator Settings")
//----
//EDSMA
get2PoleSSF(src, length) =>
PI = 2 * asin(1)
arg = sqrt(2) * PI / length
a1 = exp(-arg)
b1 = 2 * a1 * cos(arg)
c2 = b1
c3 = -pow(a1, 2)
c1 = 1 - c2 - c3
ssf = 0.0
ssf := c1 * src + c2 * nz(ssf[1]) + c3 * nz(ssf[2])
get3PoleSSF(src, length) =>
PI = 2 * asin(1)
arg = PI / length
a1 = exp(-arg)
b1 = 2 * a1 * cos(1.738 * arg)
c1 = pow(a1, 2)
coef2 = b1 + c1
coef3 = -(c1 + b1 * c1)
coef4 = pow(c1, 2)
coef1 = 1 - coef2 - coef3 - coef4
ssf = 0.0
ssf := coef1 * src + coef2 * nz(ssf[1]) + coef3 * nz(ssf[2]) + coef4 * nz(ssf[3])
ma(type, src, len) =>
float result = 0
if type=="TMA"
result := sma(sma(src, ceil(len / 2)), floor(len / 2) + 1)
if type=="MF"
ts=0.,b=0.,c=0.,os=0.
//----
alpha = 2/(len+1)
a = feedback ? z*src + (1-z)*nz(ts[1],src) : src
//----
b := a > alpha*a+(1-alpha)*nz(b[1],a) ? a : alpha*a+(1-alpha)*nz(b[1],a)
c := a < alpha*a+(1-alpha)*nz(c[1],a) ? a : alpha*a+(1-alpha)*nz(c[1],a)
os := a == b ? 1 : a == c ? 0 : os[1]
//----
upper = beta*b+(1-beta)*c
lower = beta*c+(1-beta)*b
ts := os*upper+(1-os)*lower
result := ts
if type=="LSMA"
result := linreg(src, len, 0)
if type=="SMA" // Simple
result := sma(src, len)
if type=="EMA" // Exponential
result := ema(src, len)
if type=="DEMA" // Double Exponential
e = ema(src, len)
result := 2 * e - ema(e, len)
if type=="TEMA" // Triple Exponential
e = ema(src, len)
result := 3 * (e - ema(e, len)) + ema(ema(e, len), len)
if type=="WMA" // Weighted
result := wma(src, len)
if type=="VAMA" // Volatility Adjusted
/// Copyright © 2019 to present, Joris Duyck (JD)
mid=ema(src,len)
dev=src-mid
vol_up=highest(dev,volatility_lookback)
vol_down=lowest(dev,volatility_lookback)
result := mid+avg(vol_up,vol_down)
if type=="HMA" // Hull
result := wma(2 * wma(src, len / 2) - wma(src, len), round(sqrt(len)))
if type=="JMA" // Jurik
/// Copyright © 2018 Alex Orekhov (everget)
/// Copyright © 2017 Jurik Research and Consulting.
phaseRatio = jurik_phase < -100 ? 0.5 : jurik_phase > 100 ? 2.5 : jurik_phase / 100 + 1.5
beta = 0.45 * (len - 1) / (0.45 * (len - 1) + 2)
alpha = pow(beta, jurik_power)
jma = 0.0
e0 = 0.0
e0 := (1 - alpha) * src + alpha * nz(e0[1])
e1 = 0.0
e1 := (src - e0) * (1 - beta) + beta * nz(e1[1])
e2 = 0.0
e2 := (e0 + phaseRatio * e1 - nz(jma[1])) * pow(1 - alpha, 2) + pow(alpha, 2) * nz(e2[1])
jma := e2 + nz(jma[1])
result := jma
if type=="Kijun v2"
kijun = avg(lowest(len), highest(len))//, (open + close)/2)
conversionLine = avg(lowest(len/kidiv), highest(len/kidiv))
delta = (kijun + conversionLine)/2
result :=delta
if type=="McGinley"
mg = 0.0
ema = ema(src, len)
mg := na(mg[1]) ? ema : mg[1] + (src - mg[1]) / (len * pow(src/mg[1], 4))
result :=mg
if type=="EDSMA"
zeros = src - nz(src[2])
avgZeros = (zeros + zeros[1]) / 2
// Ehlers Super Smoother Filter
ssf = ssfPoles == 2
? get2PoleSSF(avgZeros, ssfLength)
: get3PoleSSF(avgZeros, ssfLength)
// Rescale filter in terms of Standard Deviations
stdev = stdev(ssf, len)
scaledFilter = stdev != 0
? ssf / stdev
: 0
alpha = 5 * abs(scaledFilter) / len
edsma = 0.0
edsma := alpha * src + (1 - alpha) * nz(edsma[1])
result := edsma
result
///SSL 1 and SSL2
emaHigh = ma(maType, high, len)
emaLow = ma(maType, low, len)
maHigh = ma(SSL2Type, high, len2)
maLow = ma(SSL2Type, low, len2)
///EXIT
ExitHigh = ma(SSL3Type, high, len3)
ExitLow = ma(SSL3Type, low, len3)
///Keltner Baseline Channel
BBMC = ma(maType, close, len)
useTrueRange = input(true, group="SSL Hybrid Indicator Settings")
multy = input(0.2, step=0.05, title="Base Channel Multiplier", group="SSL Hybrid Indicator Settings")
Keltma = ma(maType, src, len)
range = useTrueRange ? tr : high - low
rangema = ema(range, len)
upperk =Keltma + rangema * multy
lowerk = Keltma - rangema * multy
//Baseline Violation Candle
open_pos = open*1
close_pos = close*1
difference = abs(close_pos-open_pos)
atr_violation = difference > atr_slen
InRange = upper_band > BBMC and lower_band < BBMC
candlesize_violation = atr_violation and InRange
plotshape(candlesize_violation, color=color.new(color.white, transp=0), size=size.tiny,style=shape.diamond, location=location.top, title="Candle Size > 1xATR")
//SSL1 VALUES
Hlv = int(na)
Hlv := close > emaHigh ? 1 : close < emaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? emaHigh : emaLow
//SSL2 VALUES
Hlv2 = int(na)
Hlv2 := close > maHigh ? 1 : close < maLow ? -1 : Hlv2[1]
sslDown2 = Hlv2 < 0 ? maHigh : maLow
//EXIT VALUES
Hlv3 = int(na)
Hlv3 := close > ExitHigh ? 1 : close < ExitLow ? -1 : Hlv3[1]
sslExit = Hlv3 < 0 ? ExitHigh : ExitLow
base_cross_Long = crossover(close, sslExit)
base_cross_Short = crossover(sslExit, close)
codiff = base_cross_Long ? 1 : base_cross_Short ? -1 : na
//COLORS
show_color_bar = input(title="Color Bars", type=input.bool, defval=true, group="SSL Hybrid Indicator Settings")
color_bar = close > upperk ? #00c3ff : close < lowerk ? #ff0062 : color.gray
color_ssl1 = close > sslDown ? #00c3ff : close < sslDown ? #ff0062 : na
//PLOTS
plotarrow(codiff, colorup=color.rgb(0, 195, 255, transp=0), colordown=color.rgb(255, 0, 98, transp=0),title="Exit Arrows", maxheight=20, offset=0)
p1 = plot(show_Baseline ? BBMC : na, color=color.new(color_bar, transp=0), linewidth=4, title='MA Baseline')
DownPlot = plot( show_SSL1 ? sslDown : na, title="SSL1", linewidth=3, color=color.new(color_ssl1, transp=10))
barcolor(show_color_bar ? color_bar : na)
up_channel = plot(show_Baseline ? upperk : na, color=color_bar, title="Baseline Upper Channel")
low_channel = plot(show_Baseline ? lowerk : na, color=color_bar, title="Basiline Lower Channel")
fill(up_channel, low_channel, color=color.new(color_bar, transp=90))
////SSL2 Continiuation from ATR
atr_crit = input(0.9, step=0.1, title="Continuation ATR Criteria", group="SSL Hybrid Indicator Settings")
upper_half = atr_slen * atr_crit + close
lower_half = close - atr_slen * atr_crit
buy_inatr = lower_half < sslDown2
sell_inatr = upper_half > sslDown2
sell_cont = close < BBMC and close < sslDown2
buy_cont = close > BBMC and close > sslDown2
sell_atr = sell_inatr and sell_cont
buy_atr = buy_inatr and buy_cont
atr_fill = buy_atr ? color.green : sell_atr ? color.purple : color.white
LongPlot = plot(sslDown2, title="SSL2", linewidth=2, color=color.new(atr_fill, transp=0), style=plot.style_circles, display=display.none)
u = plot(show_atr ? upper_band : na, "+ATR", color=color.new(color.white, transp=80), display=display.none)
l = plot(show_atr ? lower_band : na, "-ATR", color=color.new(color.white, transp=80), display=display.none)
// ---------------------------- QQE MOD INDICATOR ------------------------------
RSI_Period = input(6, title='RSI Length')
SF = input(5, title='RSI Smoothing')
QQE = input(3, title='Fast QQE Factor')
ThreshHold = input(3, title="Thresh-hold")
rsi_src = input(close, title="RSI Source")
Wilders_Period = RSI_Period * 2 - 1
Rsi = rsi(rsi_src, RSI_Period)
RsiMa = ema(Rsi, SF)
AtrRsi = abs(RsiMa[1] - RsiMa)
MaAtrRsi = ema(AtrRsi, Wilders_Period)
dar = ema(MaAtrRsi, Wilders_Period) * QQE
longband = 0.0
shortband = 0.0
trend = 0
DeltaFastAtrRsi = dar
RSIndex = RsiMa
newshortband = RSIndex + DeltaFastAtrRsi
newlongband = RSIndex - DeltaFastAtrRsi
longband := RSIndex[1] > longband[1] and RSIndex > longband[1] ?
max(longband[1], newlongband) : newlongband
shortband := RSIndex[1] < shortband[1] and RSIndex < shortband[1] ?
min(shortband[1], newshortband) : newshortband
cross_1 = cross(longband[1], RSIndex)
trend := cross(RSIndex, shortband[1]) ? 1 : cross_1 ? -1 : nz(trend[1], 1)
FastAtrRsiTL = trend == 1 ? longband : shortband
////////////////////
length = input(50, minval=1, title="Bollinger Length")
bb_mult = input(0.35, minval=0.001, maxval=5, step=0.1, title="BB Multiplier")
basis = sma(FastAtrRsiTL - 50, length)
dev = bb_mult * stdev(FastAtrRsiTL - 50, length)
upper = basis + dev
lower = basis - dev
rsi_ma_color_bar = RsiMa - 50 > upper ? #00c3ff : RsiMa - 50 < lower ? #ff0062 : color.gray
// Zero cross
QQEzlong = 0
QQEzlong := nz(QQEzlong[1])
QQEzshort = 0
QQEzshort := nz(QQEzshort[1])
QQEzlong := RSIndex >= 50 ? QQEzlong + 1 : 0
QQEzshort := RSIndex < 50 ? QQEzshort + 1 : 0
////////////////////////////////////////////////////////////////
RSI_Period2 = input(6, title='RSI Length')
SF2 = input(5, title='RSI Smoothing')
QQE2 = input(1.61, title='Fast QQE2 Factor')
ThreshHold2 = input(3, title="Thresh-hold")
src2 = input(close, title="RSI Source")
Wilders_Period2 = RSI_Period2 * 2 - 1
Rsi2 = rsi(src2, RSI_Period2)
RsiMa2 = ema(Rsi2, SF2)
AtrRsi2 = abs(RsiMa2[1] - RsiMa2)
MaAtrRsi2 = ema(AtrRsi2, Wilders_Period2)
dar2 = ema(MaAtrRsi2, Wilders_Period2) * QQE2
longband2 = 0.0
shortband2 = 0.0
trend2 = 0
DeltaFastAtrRsi2 = dar2
RSIndex2 = RsiMa2
newshortband2 = RSIndex2 + DeltaFastAtrRsi2
newlongband2 = RSIndex2 - DeltaFastAtrRsi2
longband2 := RSIndex2[1] > longband2[1] and RSIndex2 > longband2[1] ?
max(longband2[1], newlongband2) : newlongband2
shortband2 := RSIndex2[1] < shortband2[1] and RSIndex2 < shortband2[1] ?
min(shortband2[1], newshortband2) : newshortband2
cross_2 = cross(longband2[1], RSIndex2)
trend2 := cross(RSIndex2, shortband2[1]) ? 1 : cross_2 ? -1 : nz(trend2[1], 1)
FastAtrRsi2TL = trend2 == 1 ? longband2 : shortband2
// Zero cross
QQE2zlong = 0
QQE2zlong := nz(QQE2zlong[1])
QQE2zshort = 0
QQE2zshort := nz(QQE2zshort[1])
QQE2zlong := RSIndex2 >= 50 ? QQE2zlong + 1 : 0
QQE2zshort := RSIndex2 < 50 ? QQE2zshort + 1 : 0
hcolor2 = RsiMa2 - 50 > ThreshHold2 ? color.silver :
RsiMa2 - 50 < 0 - ThreshHold2 ? color.silver : na
Greenbar1 = RsiMa2 - 50 > ThreshHold2
Greenbar2 = RsiMa - 50 > upper
Redbar1 = RsiMa2 - 50 < 0 - ThreshHold2
Redbar2 = RsiMa - 50 < lower
qqe_line = FastAtrRsi2TL - 50
qqe_blue_bar = Greenbar1 and Greenbar2 == 1
qqe_red_bar = Redbar1 and Redbar2 == 1
// ----------------------------------STRATEGY ----------------------------------
atr_length = input(title="ATR Length", type=input.integer, defval=14, inline="1", group="Strategy Back Test Settings")
atr = atr(atr_length)
// Back test time range
from_date = input(title="From", type=input.time, defval=timestamp("01 Aug 2021 00:00 +0100"), inline="1", group="Date Range")
to_date = input(title="To", type=input.time, defval=timestamp("01 Sep 2021 00:00 +0100"), inline="1", group="Date Range")
in_date = true
// Strategy entry and exit settings
// Should use SSL as a filter for position side
use_ssl_filter = input(title="SSL Flip as Filter", type=input.bool, defval=false, inline="1", group="Entry Settings")
// Should use SSL as a filter for position side
use_qqe_filter = input(title="QQE MOD as Filter (Please add QQE MOD indicator to your chart separately)", type=input.bool, defval=false, inline="2", group="Entry Settings")
// DCA Settings
dca1_atr_multiplier = input(title="DCA1 ATR Multiplier", type=input.float, defval=0.1, step=0.1, inline="3", group="Entry Settings")
dca1_exit_percentage = input(title="DCA1 Exit Percentage", type=input.integer, defval=20, step=1, maxval=100, inline="3", group="Entry Settings")
dca2_atr_multiplier = input(title="DCA2 ATR Multiplier", type=input.float, defval=0.3, step=0.1, inline="4", group="Entry Settings")
dca2_exit_percentage = input(title="DCA2 Exit Percentage", type=input.integer, defval=40, step=1, maxval=100, inline="4", group="Entry Settings")
dca3_atr_multiplier = input(title="DCA3 ATR Multiplier", type=input.float, defval=0.7, step=0.1, inline="5", group="Entry Settings")
dca3_exit_percentage = input(title="DCA3 Exit Percentage", type=input.integer, defval=40, step=1, maxval=100, inline="5", group="Entry Settings")
// Stop-Loss Settings
sl_atr_multiplier = input(title="SL ATR Multiplier", type=input.float, defval=1.8, step=0.1, inline="2", group="Exit Settings")
var long_sl = float(na)
var long_dca1 = float(na)
var long_dca2 = float(na)
var long_dca3 = float(na)
var short_sl = float(na)
var short_dca1 = float(na)
var short_dca2 = float(na)
var short_dca3 = float(na)
is_open_long = strategy.position_size > 0
is_open_short = strategy.position_size < 0
var in_ssl_long = false
var in_ssl_short = false
var ssl_long_entry = false
var ssl_short_entry = false
var ssl_long_exit = false
var ssl_short_exit = false
var did_prev_bar_ssl_flip = false
ssl_long = use_ssl_filter ? close > sslDown : true
ssl_short = use_ssl_filter ? close < sslDown : true
qqe_long = use_qqe_filter ? (qqe_blue_bar and qqe_line > 0) : true
qqe_short = use_qqe_filter ? (qqe_red_bar and qqe_line < 0) : true
ssl_long_entry := ssl_long and qqe_long and codiff == 1
ssl_short_entry := ssl_short and qqe_short and codiff == -1
ssl_long_exit := codiff == -1
ssl_short_exit := codiff == 1
remaining_percent = 100
var total_tokens = strategy.equity * 0.10 / close
dca1_percent = dca1_exit_percentage <= remaining_percent ? dca1_exit_percentage : remaining_percent
remaining_percent -= dca1_percent
entry_1 = total_tokens * (dca1_percent / 100)
dca2_percent = dca2_exit_percentage <= remaining_percent ? dca2_exit_percentage : remaining_percent
remaining_percent -= dca2_percent
entry_2 = total_tokens * (dca2_percent / 100)
dca3_percent = dca3_exit_percentage <= remaining_percent ? dca3_exit_percentage : remaining_percent
remaining_percent -= dca3_percent
entry_3 = total_tokens * (dca3_percent / 100)
if did_prev_bar_ssl_flip
did_prev_bar_ssl_flip := false
position_value = abs(strategy.position_size * close)
if in_ssl_long
label.new(x=bar_index, y=close, xloc=xloc.bar_index, yloc=yloc.abovebar, text=tostring(position_value), style=label.style_label_down, size=size.tiny)
else
label.new(x=bar_index, y=close, xloc=xloc.bar_index, yloc=yloc.belowbar, text=tostring(position_value), style=label.style_label_up, size=size.tiny)
if ssl_long_exit
strategy.cancel("LongEntry1")
strategy.cancel("LongEntry2")
strategy.cancel("LongEntry3")
strategy.close(id="LongEntry1", comment="Close Long1")
strategy.close(id="LongEntry2", comment="Close Long2")
strategy.close(id="LongEntry3", comment="Close Long3")
in_ssl_long := false
in_ssl_short := false
if ssl_short_exit
strategy.cancel("ShortEntry1")
strategy.cancel("ShortEntry2")
strategy.cancel("ShortEntry3")
strategy.close(id="ShortEntry1", comment="Close Short1")
strategy.close(id="ShortEntry2", comment="Close Short2")
strategy.close(id="ShortEntry3", comment="Close Short3")
in_ssl_long := false
in_ssl_short := false
if ssl_long_entry and in_date and not in_ssl_long
strategy.cancel("LongEntry1")
strategy.cancel("LongEntry2")
strategy.cancel("LongEntry3")
strategy.cancel("ShortEntry1")
strategy.cancel("ShortEntry2")
strategy.cancel("ShortEntry3")
if in_ssl_short
strategy.close(id="ShortEntry1", comment="Close Short1")
strategy.close(id="ShortEntry2", comment="Close Short2")
strategy.close(id="ShortEntry3", comment="Close Short3")
in_ssl_long := true
in_ssl_short := false
did_prev_bar_ssl_flip := true
long_sl := close - (atr * sl_atr_multiplier)
long_dca1 := close - (atr * dca1_atr_multiplier)
long_dca2 := close - (atr * dca2_atr_multiplier)
long_dca3 := close - (atr * dca3_atr_multiplier)
strategy.entry("LongEntry1", strategy.long, limit=long_dca1)
strategy.entry("LongEntry2", strategy.long, limit=long_dca2)
strategy.entry("LongEntry3", strategy.long, limit=long_dca3)
strategy.exit("LongExit1", "LongEntry1", stop=long_sl)
strategy.exit("LongExit2", "LongEntry2", stop=long_sl)
strategy.exit("LongExit3", "LongEntry3", stop=long_sl)
if ssl_short_entry and in_date and not in_ssl_short
strategy.cancel("LongEntry1")
strategy.cancel("LongEntry2")
strategy.cancel("LongEntry3")
strategy.cancel("ShortEntry1")
strategy.cancel("ShortEntry2")
strategy.cancel("ShortEntry3")
if in_ssl_long
strategy.close(id="LongEntry1", comment="Close Long1")
strategy.close(id="LongEntry2", comment="Close Long2")
strategy.close(id="LongEntry3", comment="Close Long3")
in_ssl_short := true
in_ssl_long := false
did_prev_bar_ssl_flip := true
short_sl := close + (atr * sl_atr_multiplier)
short_dca1 := close + (atr * dca1_atr_multiplier)
short_dca2 := close + (atr * dca2_atr_multiplier)
short_dca3 := close + (atr * dca3_atr_multiplier)
strategy.entry("ShortEntry1", strategy.short, limit=short_dca1)
strategy.entry("ShortEntry2", strategy.short, limit=short_dca2)
strategy.entry("ShortEntry3", strategy.short, limit=short_dca3)
strategy.exit("ShortExit1", "ShortEntry1", stop=short_sl)
strategy.exit("ShortExit2", "ShortEntry2", stop=short_sl)
strategy.exit("ShortExit3", "ShortEntry3", stop=short_sl)
더 많은
- EMA와 함께하는 전략에 따른 경향
- 이중 반전 비율 변화 바 양적 전략
- MA 트렌드 필터와 함께 볼링거 밴드 역전
- RSI 기반의 양적 거래 전략
- 다중 이동 평균 크로스오버 거래 전략
- 이동 평균 크로스오버 전략
- 자동차 S/R 브레이크업 전략
- 모멘텀 가격 채널 오픈 및 종료 전략
- 시장 트렌드 가이드와 함께 향상된 이동 평균 크로스오버 전략
- 동적 촛불 빅 양 라인 거래 전략
- 이중 이동 평균 ADX 타이밍 전략
- BB 비율 지수 추세 감소 전략
- MACD 볼링거 거북이 거래 전략
- 트리플 슈퍼 트렌드 및 스톡 RSI 전략
- 1%의 수익 이동 평균 크로스 전략
- 가중화된 양적 이동평균 크로스오버 거래 전략
- 여러 보조 RSI 지표 전략
- 이중 이동 평균 크로스오버 트렌드 전략
- 반전 볼링거 밴드 전략
- 적응 가능한 ATR-ADX 트렌드 전략 V2