Đây là một chiến lược theo xu hướng điển hình. Nó sử dụng EMA Zero-Lag nhanh và chậm để xác định hướng xu hướng, và kết hợp các cơ chế như trailing stop, take profit và kim tự tháp để theo xu hướng.
Tính toán EMA Zero-Lag nhanh và chậm bằng cách sử dụng các khoảng thời gian trơn tru khác nhau.
Tín hiệu dài được tạo ra khi EMA nhanh vượt qua EMA chậm, và tín hiệu ngắn khi EMA nhanh vượt qua EMA chậm.
Thiết lập đường dừng sau khi nhập để theo giá cao nhất / thấp nhất để kiểm soát rủi ro.
Lấy lợi nhuận khi giá đạt một tỷ lệ phần trăm nhất định để lấy lợi nhuận.
Sử dụng tính toán mở để hình thành kim tự tháp tương tự như lãi suất hỗn hợp.
EMA Zero-Lag có sự chậm trễ ít hơn trong việc phản ứng với những thay đổi xu hướng.
Chiến lược EMA kép đơn giản và trực quan để đánh giá theo hướng.
Các thiết lập dừng lỗ và lấy lợi nhuận có hiệu quả kiểm soát lỗ giao dịch duy nhất.
Cơ chế kim tự tháp cho phép lợi nhuận nhiều hơn khi xu hướng mở rộng.
Các thiết lập tham số không chính xác có thể gây ra stop loss/take profit quá hung hăng hoặc quá bảo thủ.
Chỉ số xu hướng sai có thể bỏ lỡ thời điểm thay đổi xu hướng.
Đánh kim tự tháp có thể làm tăng tổng tổn thất khi xu hướng đảo ngược.
Các thông số cần điều chỉnh cho các sản phẩm khác nhau để tránh quá phù hợp.
Kiểm tra các khoảng thời gian EMA khác nhau để tìm kết hợp các tham số tốt hơn.
Tối ưu hóa tỷ lệ dừng / lấy để cân bằng lợi nhuận và kiểm soát rủi ro.
Điều chỉnh logic kim tự tháp để giới hạn số lượng mở tối đa mỗi hướng.
Thêm các chỉ số kỹ thuật khác cho bộ lọc đầu vào để cải thiện chất lượng tín hiệu.
Khóa giao dịch trong các giờ cụ thể để tránh các giai đoạn dễ bị tín hiệu sai.
Các thông số thử nghiệm riêng biệt trên các sản phẩm khác nhau để cải thiện độ bền.
Chiến lược này cho thấy hoạt động ổn định tổng thể với lợi nhuận điều chỉnh rủi ro tốt. Nó có thể được cải thiện hơn nữa thông qua tối ưu hóa tham số, lọc phụ trợ vv. Cũng cần phải cảnh giác với các lỗi tín hiệu tiềm ẩn trong các điều kiện thị trường nhất định. Nhìn chung chiến lược này có một khuôn khổ vững chắc và cho thấy tiềm năng trở thành một xu hướng có lợi nhuận ổn định sau chiến lược sau khi tinh chỉnh liên tục.
//@version=3
// Learn more about Autoview and how you can automate strategies like this one here: https://autoview.with.pink/
strategy("MP ZeroLag EMA", "MP 0 Strat", overlay=true, pyramiding=0, initial_capital=100000, currency=currency.USD, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, commission_type=strategy.commission.percent, commission_value=0.1)
//bgcolor ( color=black, transp=40, title='Blackground', editable=true)
///////////////////////////////////////////////
//* Backtesting Period Selector | Component *//
///////////////////////////////////////////////
testStartYear = input(2018, "Backtest Start Year")
testStartMonth = input(3, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,00,00)
testStopYear = input(77777777, "Backtest Stop Year")
testStopMonth = input(11, "Backtest Stop Month")
testStopDay = input(15, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
testPeriod() => true
/////////////////////////////////////
//* Put your strategy logic below *//
/////////////////////////////////////
// === INPUTS ===
zlmaSource = input(defval = close, title = "ZeroLag EMA Source")
zlmaFastLength = input(defval = 8, title = "ZeroLag EMA Fast Length")
zlmaSlowLength = input(defval = 21, title = "ZeroLag EMA Slow Length")
// === /INPUTS ===
// === SERIES SETUP ===
// Fast ZeroLag EMA
zema1=ema(zlmaSource, zlmaFastLength)
zema2=ema(zema1, zlmaFastLength)
c1=zema1-zema2
zlemaFast=zema1+c1
// Slow ZeroLag EMA
zema3=ema(zlmaSource, zlmaSlowLength)
zema4=ema(zema3, zlmaSlowLength)
c2=zema3-zema4
zlemaSlow=zema3+c2
// Plots and Conditions
plot(zlemaFast, title='Fast ZeroLag EMA', color = yellow, linewidth=4)
plot(zlemaSlow, title='Slow ZeroLag EMA', color = fuchsia, linewidth=4)
// Long/Short Logic
longLogic = crossover(zlemaFast,zlemaSlow) ? 1 : 0
shortLogic = crossunder(zlemaFast,zlemaSlow) ? 1 : 0
//////////////////////////
//* Strategy Component *//
//////////////////////////
isLong = input(false, "Longs Only")
isShort = input(false, "Shorts Only")
isFlip = input(false, "Flip the Opens")
long = longLogic
short = shortLogic
if isFlip
long := shortLogic
short := longLogic
else
long := longLogic
short := shortLogic
if isLong
long := long
short := na
if isShort
long := na
short := short
////////////////////////////////
//======[ Signal Count ]======//
////////////////////////////////
sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
if long
sectionLongs := sectionLongs + 1
sectionShorts := 0
if short
sectionLongs := 0
sectionShorts := sectionShorts + 1
//////////////////////////////
//======[ Pyramiding ]======//
//////////////////////////////
pyrl = input(1, "Pyramiding less than") // If your count is less than this number
pyre = input(0, "Pyramiding equal to") // If your count is equal to this number
pyrg = input(1000000, "Pyramiding greater than") // If your count is greater than this number
longCondition = long and sectionLongs <= pyrl or long and sectionLongs >= pyrg or long and sectionLongs == pyre ? 1 : 0
shortCondition = short and sectionShorts <= pyrl or short and sectionShorts >= pyrg or short and sectionShorts == pyre ? 1 : 0
////////////////////////////////
//======[ Entry Prices ]======//
////////////////////////////////
last_open_longCondition = na
last_open_shortCondition = na
last_open_longCondition := longCondition ? close : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close : nz(last_open_shortCondition[1])
////////////////////////////////////
//======[ Open Order Count ]======//
////////////////////////////////////
sectionLongConditions = 0
sectionLongConditions := nz(sectionLongConditions[1])
sectionShortConditions = 0
sectionShortConditions := nz(sectionShortConditions[1])
if longCondition
sectionLongConditions := sectionLongConditions + 1
sectionShortConditions := 0
if shortCondition
sectionLongConditions := 0
sectionShortConditions := sectionShortConditions + 1
///////////////////////////////////////////////
//======[ Position Check (long/short) ]======//
///////////////////////////////////////////////
last_longCondition = na
last_shortCondition = na
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
/////////////////////////////////////
//======[ Position Averages ]======//
/////////////////////////////////////
totalLongs = 0.0
totalLongs := nz(totalLongs[1])
totalShorts = 0.0
totalShorts := nz(totalShorts[1])
averageLongs = 0.0
averageLongs := nz(averageLongs[1])
averageShorts = 0.0
averageShorts := nz(averageShorts[1])
if longCondition
totalLongs := totalLongs + last_open_longCondition
totalShorts := 0.0
if shortCondition
totalLongs := 0.0
totalShorts := totalShorts + last_open_shortCondition
averageLongs := totalLongs / sectionLongConditions
averageShorts := totalShorts / sectionShortConditions
/////////////////////////////////
//======[ Trailing Stop ]======//
/////////////////////////////////
isTS = input(false, "Trailing Stop")
tsi = input(1300, "Activate Trailing Stop Price (%). Divided by 100 (1 = 0.01%)") / 100
ts = input(400, "Trailing Stop (%). Divided by 100 (1 = 0.01%)") / 100
last_high = na
last_low = na
last_high_short = na
last_low_short = na
last_high := not in_longCondition ? na : in_longCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_high_short := not in_shortCondition ? na : in_shortCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_shortCondition ? na : in_shortCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
last_low_short := not in_longCondition ? na : in_longCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
long_ts = isTS and not na(last_high) and low <= last_high - last_high / 100 * ts and longCondition == 0 and last_high >= averageLongs + averageLongs / 100 * tsi
short_ts = isTS and not na(last_low) and high >= last_low + last_low / 100 * ts and shortCondition == 0 and last_low <= averageShorts - averageShorts/ 100 * tsi
///////////////////////////////
//======[ Take Profit ]======//
///////////////////////////////
isTP = input(true, "Take Profit")
tp = input(300, "Take Profit (%). Divided by 100 (1 = 0.01%)") / 100
long_tp = isTP and close > averageLongs + averageLongs / 100 * tp and not longCondition
short_tp = isTP and close < averageShorts - averageShorts / 100 * tp and not shortCondition
/////////////////////////////
//======[ Stop Loss ]======//
/////////////////////////////
isSL = input(false, "Stop Loss")
sl = input(750, "Stop Loss (%). Divided by 100 (1 = 0.01%)") / 100
long_sl = isSL and close < averageLongs - averageLongs / 100 * sl and longCondition == 0
short_sl = isSL and close > averageShorts + averageShorts / 100 * sl and shortCondition == 0
/////////////////////////////////
//======[ Close Signals ]======//
/////////////////////////////////
longClose = long_tp or long_sl or long_ts ? 1 : 0
shortClose = short_tp or short_sl or short_ts ? 1: 0
///////////////////////////////
//======[ Plot Colors ]======//
///////////////////////////////
longCloseCol = na
shortCloseCol = na
longCloseCol := long_tp ? purple : long_sl ? maroon : long_ts ? blue : longCloseCol[1]
shortCloseCol := short_tp ? purple : short_sl ? maroon : short_ts ? blue : shortCloseCol[1]
tpColor = isTP and in_longCondition ? purple : isTP and in_shortCondition ? purple : white
slColor = isSL and in_longCondition ? red : isSL and in_shortCondition ? red : white
//////////////////////////////////
//======[ Strategy Plots ]======//
//////////////////////////////////
plot(isTS and in_longCondition ? averageLongs + averageLongs / 100 * tsi : na, "Long Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_longCondition and last_high >= averageLongs + averageLongs / 100 * tsi ? last_high - last_high / 100 * ts : na, "Long Trailing", fuchsia, style=2, linewidth=3)
plot(isTS and in_shortCondition ? averageShorts - averageShorts/ 100 * tsi : na, "Short Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_shortCondition and last_low <= averageShorts - averageShorts/ 100 * tsi ? last_low + last_low / 100 * ts : na, "Short Trailing", fuchsia, style=2, linewidth=3)
plot(isTP and in_longCondition and last_high < averageLongs + averageLongs / 100 * tp ? averageLongs + averageLongs / 100 * tp : na, "Long TP", tpColor, style=3, linewidth=2)
plot(isTP and in_shortCondition and last_low > averageShorts - averageShorts / 100 * tp ? averageShorts - averageShorts / 100 * tp : na, "Short TP", tpColor, style=3, linewidth=2)
plot(isSL and in_longCondition and last_low_short > averageLongs - averageLongs / 100 * sl ? averageLongs - averageLongs / 100 * sl : na, "Long SL", slColor, style=3, linewidth=2)
plot(isSL and in_shortCondition and last_high_short < averageShorts + averageShorts / 100 * sl ? averageShorts + averageShorts / 100 * sl : na, "Short SL", slColor, style=3, linewidth=2)
///////////////////////////////
//======[ Alert Plots ]======//
///////////////////////////////
// Old Signal Plots
//plot(longCondition, "Long", green)
//plot(shortCondition, "Short", red)
//plot(longClose, "Long Close", longCloseCol)
//plot(shortClose, "Short Close", shortCloseCol)
// New Signal Plots
//plotshape(series=longCondition, title="Long", style=shape.triangleup, location=location.belowbar, color=green, size=size.tiny)
//plotshape(series=shortCondition, title="Short", style=shape.triangledown, location=location.abovebar, color=red, size=size.tiny)
//plotshape(series=longClose, title="Long Close", style=shape.triangleup, location=location.belowbar, color=blue, size=size.tiny)
//plotshape(series=shortClose, title="Short Close", style=shape.triangledown, location=location.abovebar, color=purple, size=size.tiny)
//alertcondition(condition=longCondition, title="Long", message="")
//alertcondition(condition=shortCondition, title="Short", message="")
//alertcondition(condition=longClose, title="Long Close", message="")
//alertcondition(condition=shortClose, title="Short Close", message="")
///////////////////////////////////
//======[ Reset Variables ]======//
///////////////////////////////////
if longClose or not in_longCondition
averageLongs := 0
totalLongs := 0.0
sectionLongs := 0
sectionLongConditions := 0
if shortClose or not in_shortCondition
averageShorts := 0
totalShorts := 0.0
sectionShorts := 0
sectionShortConditions := 0
////////////////////////////////////////////
//======[ Strategy Entry and Exits ]======//
////////////////////////////////////////////
if testPeriod()
strategy.entry("Long", 1, when=longCondition)
strategy.entry("Short", 0, when=shortCondition)
strategy.close("Long", when=longClose)
strategy.close("Short", when=shortClose)
//////NEW STUFF
//temainput = input(24, minval=1, title="Fast TEMA")
//hullinput = input(39, minval=1, title="Slow hullMA")
//rmainput = input(48, minval=1, title="RMA (BB Signal)")
//bblength = input(20, minval=1, title="BB Length")
//mult = input(1.5, minval=0.001, maxval=50, title="BB stdev Mult")
//src = input(defval=close, type=source, title="Source")
//Moving Average Params
//hullMA
//hullma = wma(2*wma(close, hullinput/2)-wma(close, hullinput), round(sqrt(hullinput)))
//TEMA
//ema = ema(close, temainput)
//ema1 = ema(ema, temainput)
//ema2 = ema(ema1, temainput)
//tema = 3 * (ema - ema1) + ema2
//RMA
//rma = ema(close, 96)
//BB
//basis = sma(tema, bblength)
//dev = mult * stdev(tema, bblength)
//upper = basis + dev
//lower = basis - dev
//Color Swaps
//ribbon = tema>=hullma ? #c0fff4 : #ffbcc8
//bandcolor = rma>=basis ? #ffbcc8 : #c0fff4
//Plots
//plot(basis, title="Bollinger Band Basis", color=red, transp=0)
//upband = plot(upper, color=#ffbcc8, transp=100, editable=false)
//downband = plot(lower, color=#ffbcc8, transp=100, editable=false)
//Fills
//temap = plot(tema, title="TEMA", color=white, transp=100, editable=false)
//emap = plot(hullma, title="EMA", color=white, transp=100, editable=false)
//fill (temap, emap, color=ribbon, title="MA Ribbon", transp=50)
//fill(upband, downband, title="Bollinger Band Background", color=bandcolor)
///////END NEW
///--------New, DW Art----------
//Period
per = input(defval=34, title="Lookback Period")
//Current Resolution
res = input(defval=30, title="Resolution")
//Deviations
ndev = input(defval=7, minval=0, maxval=7, title="Number of Fibonacci Volatility Deviations")
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Definitions
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Source
src = close
dsrc = high - low
//Periods Per Annum
ppa = (1440/res)*365
//Periodic Volatility
Si = log(close/close[1])
Sm = avg(Si, per)
pv = (sqrt((sum(pow((Si - Sm), 2), per))/(per*ppa)))
//Price Geometric Moving Averages
lmean = log(src)
smean = sum(lmean,per)
gma = exp(smean/per)
lmeand = log(dsrc)
smeand = sum(lmeand,per)
gmad = exp(smeand/per)
//Deviations
dev = gmad*pv
ud1 = gma + dev
dd1 = gma - dev
ud2 = gma + dev*2
dd2 = gma - dev*2
ud3 = gma + dev*3
dd3 = gma - dev*3
ud5 = gma + dev*5
dd5 = gma - dev*5
ud8 = gma + dev*8
dd8 = gma - dev*8
ud13 = gma + dev*13
dd13 = gma - dev*13
ud21 = gma + dev*21
dd21 = gma - dev*21
u1 = (ndev==1) or (ndev==2) or (ndev==3) or (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? ud1 : na
d1 = (ndev==1) or (ndev==2) or (ndev==3) or (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? dd1 : na
u2 = (ndev==2) or (ndev==3) or (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? ud2 : na
d2 = (ndev==2) or (ndev==3) or (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? dd2 : na
u3 = (ndev==3) or (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? ud3 : na
d3 = (ndev==3) or (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? dd3 : na
u5 = (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? ud5 : na
d5 = (ndev==4) or (ndev==5) or (ndev==6) or (ndev==7) ? dd5 : na
u8 = (ndev==5) or (ndev==6) or (ndev==7) ? ud8 : na
d8 = (ndev==5) or (ndev==6) or (ndev==7) ? dd8 : na
u13 = (ndev==6) or (ndev==7) ? ud13 : na
d13 = (ndev==6) or (ndev==7) ? dd13 : na
u21 = (ndev==7) ? ud21 : na
d21 = (ndev==7) ? dd21 : na
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Plots
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
//GMA
gp = plot(gma, color=black, title="GMA")
//Deviations
u21p = plot(u21, color=lime, title="Upper Deviation x 21", transp=100)
u13p = plot(u13, color=lime, title="Upper Deviation x 13", transp=100)
u8p = plot(u8, color=lime, title="Upper Deviation x 8", transp=100)
u5p = plot(u5, color=lime, title="Upper Deviation x 5", transp=100)
u3p = plot(u3, color=lime, title="Upper Deviation x 3", transp=100)
u2p = plot(u2, color=lime, title="Upper Deviation x 2", transp=100)
u1p = plot(u1, color=lime, title="Uper Deviation", transp=100)
d1p = plot(d1, color=red, title="Lower Deviation", transp=100)
d2p = plot(d2, color=red, title="Lower Deviation x 2", transp=100)
d3p = plot(d3, color=red, title="Lower Deviation x 3", transp=100)
d5p = plot(d5, color=red, title="Lower Deviation x 5", transp=100)
d8p = plot(d8, color=red, title="Lower Deviation x 8", transp=100)
d13p = plot(d13, color=red, title="Lower Deviation x 13", transp=100)
d21p = plot(d21, color=red, title="Lower Deviation x 21", transp=100)
//Fills
fill(u21p, gp, color=silver, transp=90)
fill(u13p, gp, color=silver, transp=90)
fill(u8p, gp, color=silver, transp=90)
fill(u5p, gp, color=silver, transp=90)
fill(u3p, gp, color=silver, transp=90)
fill(u2p, gp, color=silver, transp=90)
fill(u1p, gp, color=silver, transp=90)
fill(d1p, gp, color=silver, transp=90)
fill(d2p, gp, color=silver, transp=90)
fill(d3p, gp, color=silver, transp=90)
fill(d5p, gp, color=silver, transp=90)
fill(d8p, gp, color=silver, transp=90)
fill(d13p, gp, color=silver, transp=90)
fill(d21p, gp, color=silver, transp=90)