Chiến lược xu hướng xếp hạng đa trung bình động
Tác giả:ChaoZhang, Ngày: 2023-10-17 13:11:25Tags:
Tổng quan
Chiến lược này phân tích xu hướng giá từ nhiều góc bằng cách áp dụng nhiều loại trung bình động, tạo thành một tín hiệu xếp hạng toàn diện để xác định hướng mở cửa. Chiến lược có những ưu điểm sau: 1) Nhiều trung bình động tạo thành một hệ thống xếp hạng để cải thiện độ chính xác phán đoán; 2) Điều chỉnh linh hoạt các thông số hệ thống xếp hạng để thích nghi với các loại khác nhau; 3) Điều kiện xếp hạng nhập cảnh có thể cấu hình để kiểm soát rủi ro.
Chiến lược logic
-
Chiến lược sử dụng tổng cộng 17 loại trung bình động khác nhau, bao gồm SMA, EMA, ALMA, SMMA, LSMA, VWMA, DEMA, HMA, KAMA, TEMA, ZLEMA, TRIMA, T3, v.v.
-
Đối với mỗi đường trung bình động, hãy đánh giá mối quan hệ của nó với giá đóng cửa. Nếu đường trung bình động thấp hơn giá đóng cửa, hãy đưa 1 điểm xếp hạng. Nếu cao hơn, hãy đưa -1 điểm xếp hạng. Nếu không thể xác định, đừng đưa ra xếp hạng.
-
Tổng hợp tất cả các xếp hạng của các đường trung bình động, và chia cho số lượng các đường trung bình động có thể tính, để có được một xếp hạng toàn diện.
-
So sánh xếp hạng toàn diện với ngưỡng xếp hạng đầu vào để xác định hướng mở. Nếu xếp hạng toàn diện đạt ngưỡng dài, đi dài. Nếu đạt ngưỡng ngắn, đi ngắn.
-
Việc áp dụng các đường trung bình động của các giai đoạn khác nhau có thể đánh giá xu hướng ngắn hạn và dài hạn.
Ưu điểm
-
Nhiều xếp hạng trung bình động cải thiện độ chính xác
So với một hoặc một vài chỉ số trung bình động, chiến lược sử dụng 17 chỉ số trung bình động khác nhau để xếp hạng, có thể đánh giá tốt hơn hướng xu hướng thị trường từ nhiều góc độ hơn, giảm độ lệch của bất kỳ chỉ số đơn lẻ nào.
-
Các tham số có thể cấu hình của hệ thống xếp hạng thích nghi với các loại khác nhau
Các khoảng thời gian trung bình động và ngưỡng xếp hạng trong hệ thống xếp hạng có thể được cấu hình thông qua các tham số, làm cho chiến lược thích nghi với các đặc điểm khác nhau của các loại giao dịch, điều này có lợi cho tối ưu hóa.
-
Điều kiện xếp hạng nhập cảnh có thể cấu hình
Chiến lược cho phép cấu hình các ngưỡng xếp hạng đầu vào dài và ngắn. Các tín hiệu chỉ được tạo ra khi xếp hạng toàn diện đạt ngưỡng, tránh mở sai trong điều kiện thị trường không rõ ràng. Cài đặt ngưỡng đầu vào hợp lý giúp giảm các giao dịch không cần thiết và kiểm soát rủi ro.
Rủi ro và giải pháp
-
Hiệu ứng có thể kém đối với các loại cá nhân
Các thiết lập tham số của chiến lược này được thiết kế cho thị trường tổng thể và có thể không hoạt động tốt cho một số giống cụ thể.
-
Tỷ lệ lỗi cao hơn trong các thị trường xu hướng hỗn hợp
Chiến lược này có xu hướng tạo ra tín hiệu sai khi thị trường hỗn hợp. Giải pháp là nâng ngưỡng xếp hạng nhập cảnh để giảm giao dịch trong điều kiện thị trường như vậy.
-
Tối ưu hóa tham số định kỳ có thể cần thiết cho hoạt động lâu dài
Khi điều kiện thị trường liên tục thay đổi, các tham số cố định có thể dẫn đến giảm hiệu quả chiến lược.
Hướng dẫn tối ưu hóa
-
Thêm các chỉ số khác cho xếp hạng, chẳng hạn như chỉ số biến động, chỉ số khối lượng, v.v. để cung cấp nhiều chiều kích đánh giá hơn.
-
Kiểm tra và tối ưu hóa các thông số riêng biệt cho các giống khác nhau để cải thiện khả năng thích nghi.
-
Thiết lập thời gian backtest dài hơn như nửa năm, một năm, để quan sát thời gian hiệu quả của tham số.
-
Nghiên cứu tác động thực tế của các đường trung bình động khác nhau trong các giai đoạn khác nhau để chọn kết hợp tốt hơn.
-
Hãy thử các phương pháp máy học để tự động tối ưu hóa các thông số.
Kết luận
Chiến lược này thiết lập một hệ thống xếp hạng của nhiều trung bình động để đạt được đánh giá đa góc về xu hướng thị trường. Nó có lợi thế của các tham số có thể cấu hình để thích nghi linh hoạt với các loại khác nhau và kiểm soát rủi ro chiến lược thông qua điều chỉnh tham số. Ngoài ra, hệ thống xếp hạng có thể được tối ưu hóa và cải thiện liên tục để tăng cường hiệu suất chiến lược. Nói chung, chiến lược sử dụng các hiệu ứng của nhiều chỉ số kỹ thuật để hình thành khả năng theo dõi xu hướng mạnh mẽ.
/*backtest
start: 2023-10-09 00:00:00
end: 2023-10-12 02: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/
// © exlux99
//@version=5
strategy(title='Ultra Moving Average Rating Trend Strategy', overlay=true) //, pyramiding=1,initial_capital = 1000, default_qty_type= strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills=false, slippage=0,commission_type=strategy.commission.percent,commission_value=0.03)
// //
//==========DEMA
getDEMA(src, len) =>
dema = 2 * ta.ema(src, len) - ta.ema(ta.ema(src, len), len)
dema
//==========HMA
getHULLMA(src, len) =>
hullma = ta.wma(2 * ta.wma(src, len / 2) - ta.wma(src, len), math.round(math.sqrt(len)))
hullma
//==========KAMA
getKAMA(src, len, k1, k2) =>
change = math.abs(ta.change(src, len))
volatility = math.sum(math.abs(ta.change(src)), len)
efficiency_ratio = volatility != 0 ? change / volatility : 0
kama = 0.0
fast = 2 / (k1 + 1)
slow = 2 / (k2 + 1)
smooth_const = math.pow(efficiency_ratio * (fast - slow) + slow, 2)
kama := nz(kama[1]) + smooth_const * (src - nz(kama[1]))
kama
//==========TEMA
getTEMA(src, len) =>
e = ta.ema(src, len)
tema = 3 * (e - ta.ema(e, len)) + ta.ema(ta.ema(e, len), len)
tema
//==========ZLEMA
getZLEMA(src, len) =>
zlemalag_1 = (len - 1) / 2
zlemadata_1 = src + src - src[zlemalag_1]
zlema = ta.ema(zlemadata_1, len)
zlema
//==========FRAMA
getFRAMA(src, len) =>
Price = src
N = len
if N % 2 != 0
N += 1
N
N1 = 0.0
N2 = 0.0
N3 = 0.0
HH = 0.0
LL = 0.0
Dimen = 0.0
alpha = 0.0
Filt = 0.0
N3 := (ta.highest(N) - ta.lowest(N)) / N
HH := ta.highest(N / 2 - 1)
LL := ta.lowest(N / 2 - 1)
N1 := (HH - LL) / (N / 2)
HH := high[N / 2]
LL := low[N / 2]
for i = N / 2 to N - 1 by 1
if high[i] > HH
HH := high[i]
HH
if low[i] < LL
LL := low[i]
LL
N2 := (HH - LL) / (N / 2)
if N1 > 0 and N2 > 0 and N3 > 0
Dimen := (math.log(N1 + N2) - math.log(N3)) / math.log(2)
Dimen
alpha := math.exp(-4.6 * (Dimen - 1))
if alpha < .01
alpha := .01
alpha
if alpha > 1
alpha := 1
alpha
Filt := alpha * Price + (1 - alpha) * nz(Filt[1], 1)
if bar_index < N + 1
Filt := Price
Filt
Filt
//==========VIDYA
getVIDYA(src, len) =>
mom = ta.change(src)
upSum = math.sum(math.max(mom, 0), len)
downSum = math.sum(-math.min(mom, 0), len)
out = (upSum - downSum) / (upSum + downSum)
cmo = math.abs(out)
alpha = 2 / (len + 1)
vidya = 0.0
vidya := src * alpha * cmo + nz(vidya[1]) * (1 - alpha * cmo)
vidya
//==========JMA
getJMA(src, len, power, phase) =>
phase_ratio = phase < -100 ? 0.5 : phase > 100 ? 2.5 : phase / 100 + 1.5
beta = 0.45 * (len - 1) / (0.45 * (len - 1) + 2)
alpha = math.pow(beta, power)
MA1 = 0.0
Det0 = 0.0
MA2 = 0.0
Det1 = 0.0
JMA = 0.0
MA1 := (1 - alpha) * src + alpha * nz(MA1[1])
Det0 := (src - MA1) * (1 - beta) + beta * nz(Det0[1])
MA2 := MA1 + phase_ratio * Det0
Det1 := (MA2 - nz(JMA[1])) * math.pow(1 - alpha, 2) + math.pow(alpha, 2) * nz(Det1[1])
JMA := nz(JMA[1]) + Det1
JMA
//==========T3
getT3(src, len, vFactor) =>
ema1 = ta.ema(src, len)
ema2 = ta.ema(ema1, len)
ema3 = ta.ema(ema2, len)
ema4 = ta.ema(ema3, len)
ema5 = ta.ema(ema4, len)
ema6 = ta.ema(ema5, len)
c1 = -1 * math.pow(vFactor, 3)
c2 = 3 * math.pow(vFactor, 2) + 3 * math.pow(vFactor, 3)
c3 = -6 * math.pow(vFactor, 2) - 3 * vFactor - 3 * math.pow(vFactor, 3)
c4 = 1 + 3 * vFactor + math.pow(vFactor, 3) + 3 * math.pow(vFactor, 2)
T3 = c1 * ema6 + c2 * ema5 + c3 * ema4 + c4 * ema3
T3
//==========TRIMA
getTRIMA(src, len) =>
N = len + 1
Nm = math.round(N / 2)
TRIMA = ta.sma(ta.sma(src, Nm), Nm)
TRIMA
//-------------- FUNCTIONS
dirmov(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)
[plus, minus]
adx(dilen, adxlen) =>
[plus, minus] = dirmov(dilen)
sum = plus + minus
adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen)
adx
src = close
res = input.timeframe("", title="Indicator Timeframe")
// Ichimoku Cloud
donchian(len) => math.avg(ta.lowest(len), ta.highest(len))
ichimoku_cloud() =>
conversionLine = donchian(9)
baseLine = donchian(26)
leadLine1 = math.avg(conversionLine, baseLine)
leadLine2 = donchian(52)
[conversionLine, baseLine, leadLine1, leadLine2]
calcRatingMA(ma, src) => na(ma) or na(src) ? na : (ma == src ? 0 : ( ma < src ? 1 : -1 ))
calcRating(buy, sell) => buy ? 1 : ( sell ? -1 : 0 )
calcRatingAll() =>
//============== MA =================
SMA10 = ta.sma(close, 10)
SMA20 = ta.sma(close, 20)
SMA30 = ta.sma(close, 30)
SMA50 = ta.sma(close, 50)
SMA100 = ta.sma(close, 100)
SMA200 = ta.sma(close, 200)
EMA10 = ta.ema(close, 10)
EMA20 = ta.ema(close, 20)
EMA30 = ta.ema(close, 30)
EMA50 = ta.ema(close, 50)
EMA100 = ta.ema(close, 100)
EMA200 = ta.ema(close, 200)
ALMA10 = ta.alma(close, 10, 0.85, 6)
ALMA20 = ta.alma(close, 20, 0.85, 6)
ALMA50 = ta.alma(close, 50, 0.85, 6)
ALMA100 = ta.alma(close, 100, 0.85, 6)
ALMA200 = ta.alma(close, 200, 0.85, 6)
SMMA10 = ta.rma(close, 10)
SMMA20 = ta.rma(close, 20)
SMMA50 = ta.rma(close, 50)
SMMA100 = ta.rma(close, 100)
SMMA200 = ta.rma(close, 200)
LSMA10 = ta.linreg(close, 10, 0)
LSMA20 = ta.linreg(close, 20, 0)
LSMA50 = ta.linreg(close, 50, 0)
LSMA100 = ta.linreg(close, 100, 0)
LSMA200 = ta.linreg(close, 200, 0)
VWMA10 = ta.vwma(close, 10)
VWMA20 = ta.vwma(close, 20)
VWMA50 = ta.vwma(close, 50)
VWMA100 = ta.vwma(close, 100)
VWMA200 = ta.vwma(close, 200)
DEMA10 = getDEMA(close, 10)
DEMA20 = getDEMA(close, 20)
DEMA50 = getDEMA(close, 50)
DEMA100 =getDEMA(close, 100)
DEMA200 = getDEMA(close, 200)
HMA10 = ta.hma(close, 10)
HMA20 = ta.hma(close, 20)
HMA50 = ta.hma(close, 50)
HMA100 = ta.hma(close, 100)
HMA200 = ta.hma(close, 200)
KAMA10 = getKAMA(close, 10, 2, 30)
KAMA20 = getKAMA(close, 20, 2, 30)
KAMA50 = getKAMA(close, 50, 2, 30)
KAMA100 = getKAMA(close, 100, 2, 30)
KAMA200 = getKAMA(close, 200 , 2, 30)
FRAMA10 = getFRAMA(close, 10)
FRAMA20 = getFRAMA(close, 20)
FRAMA50 = getFRAMA(close, 50)
FRAMA100 =getFRAMA(close, 100)
FRAMA200 = getFRAMA(close, 200)
VIDMA10 = getVIDYA(close, 10)
VIDMA20 = getVIDYA(close, 20)
VIDMA50 = getVIDYA(close, 50)
VIDMA100 =getVIDYA(close, 100)
VIDMA200 = getVIDYA(close, 200)
JMA10 = getJMA(close, 10, 2, 50)
JMA20 = getJMA(close, 20, 2, 50)
JMA50 = getJMA(close, 50, 2, 50)
JMA100 =getJMA(close, 100, 2, 50)
JMA200 = getJMA(close, 200, 2, 50)
TEMA10 = getTEMA(close, 10)
TEMA20 = getTEMA(close, 20)
TEMA50 = getTEMA(close, 50)
TEMA100 =getTEMA(close, 100)
TEMA200 = getTEMA(close, 200)
ZLEMA10 = getZLEMA(close, 10)
ZLEMA20 = getZLEMA(close, 20)
ZLEMA50 = getZLEMA(close, 50)
ZLEMA100 =getZLEMA(close, 100)
ZLEMA200 = getZLEMA(close, 200)
TRIMA10 = getTRIMA(close, 10)
TRIMA20 = getTRIMA(close, 20)
TRIMA50 = getTRIMA(close, 50)
TRIMA100 =getTRIMA(close, 100)
TRIMA200 = getTRIMA(close, 200)
T3MA10 = getT3(close, 10, 0.7)
T3MA20 = getT3(close, 20, 0.7)
T3MA50 = getT3(close, 50, 0.7)
T3MA100 =getT3(close, 100, 0.7)
T3MA200 = getT3(close, 200, 0.7)
[IC_CLine, IC_BLine, IC_Lead1, IC_Lead2] = ichimoku_cloud()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PriceAvg = ta.ema(close, 50)
DownTrend = close < PriceAvg
UpTrend = close > PriceAvg
// calculate trading recommendation based on SMA/EMA
float ratingMA = 0
float ratingMAC = 0
float ratingSMA10 = na
if not na(SMA10)
ratingSMA10 := calcRatingMA(SMA10, close)
ratingMA := ratingMA + ratingSMA10
ratingMAC := ratingMAC + 1
float ratingSMA20 = na
if not na(SMA20)
ratingSMA20 := calcRatingMA(SMA20, close)
ratingMA := ratingMA + ratingSMA20
ratingMAC := ratingMAC + 1
float ratingSMA30 = na
if not na(SMA30)
ratingSMA30 := calcRatingMA(SMA30, close)
ratingMA := ratingMA + ratingSMA30
ratingMAC := ratingMAC + 1
float ratingSMA50 = na
if not na(SMA50)
ratingSMA50 := calcRatingMA(SMA50, close)
ratingMA := ratingMA + ratingSMA50
ratingMAC := ratingMAC + 1
float ratingSMA100 = na
if not na(SMA100)
ratingSMA100 := calcRatingMA(SMA100, close)
ratingMA := ratingMA + ratingSMA100
ratingMAC := ratingMAC + 1
float ratingSMA200 = na
if not na(SMA200)
ratingSMA200 := calcRatingMA(SMA200, close)
ratingMA := ratingMA + ratingSMA200
ratingMAC := ratingMAC + 1
float ratingEMA10 = na
if not na(EMA10)
ratingEMA10 := calcRatingMA(EMA10, close)
ratingMA := ratingMA + ratingEMA10
ratingMAC := ratingMAC + 1
float ratingEMA20 = na
if not na(EMA20)
ratingEMA20 := calcRatingMA(EMA20, close)
ratingMA := ratingMA + ratingEMA20
ratingMAC := ratingMAC + 1
float ratingEMA30 = na
if not na(EMA30)
ratingEMA30 := calcRatingMA(EMA30, close)
ratingMA := ratingMA + ratingEMA30
ratingMAC := ratingMAC + 1
float ratingEMA50 = na
if not na(EMA50)
ratingEMA50 := calcRatingMA(EMA50, close)
ratingMA := ratingMA + ratingEMA50
ratingMAC := ratingMAC + 1
float ratingEMA100 = na
if not na(EMA100)
ratingEMA100 := calcRatingMA(EMA100, close)
ratingMA := ratingMA + ratingEMA100
ratingMAC := ratingMAC + 1
float ratingEMA200 = na
if not na(EMA200)
ratingEMA200 := calcRatingMA(EMA200, close)
ratingMA := ratingMA + ratingEMA200
ratingMAC := ratingMAC + 1
///////////////////////////
float ratingALMA10 = na
if not na(ALMA10)
ratingALMA10 := calcRatingMA(ALMA10, close)
ratingMA := ratingMA + ratingALMA10
ratingMAC := ratingMAC + 1
float ratingALMA20 = na
if not na(ALMA20)
ratingALMA20 := calcRatingMA(ALMA20, close)
ratingMA := ratingMA + ratingALMA20
ratingMAC := ratingMAC + 1
float ratingALMA50 = na
if not na(ALMA50)
ratingALMA50 := calcRatingMA(ALMA50, close)
ratingMA := ratingMA + ratingALMA50
ratingMAC := ratingMAC + 1
float ratingALMA100 = na
if not na(ALMA100)
ratingALMA100 := calcRatingMA(ALMA100, close)
ratingMA := ratingMA + ratingALMA100
ratingMAC := ratingMAC + 1
float ratingALMA200 = na
if not na(ALMA200)
ratingALMA200 := calcRatingMA(ALMA200, close)
ratingMA := ratingMA + ratingALMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingSMMA10 = na
if not na(SMMA10)
ratingSMMA10 := calcRatingMA(SMMA10, close)
ratingMA := ratingMA + ratingSMMA10
ratingMAC := ratingMAC + 1
float ratingSMMA20 = na
if not na(SMMA20)
ratingSMMA20 := calcRatingMA(SMMA20, close)
ratingMA := ratingMA + ratingSMMA20
ratingMAC := ratingMAC + 1
float ratingSMMA50 = na
if not na(SMMA50)
ratingSMMA50 := calcRatingMA(SMMA50, close)
ratingMA := ratingMA + ratingSMMA50
ratingMAC := ratingMAC + 1
float ratingSMMA100 = na
if not na(SMMA100)
ratingSMMA100 := calcRatingMA(SMMA100, close)
ratingMA := ratingMA + ratingSMMA100
ratingMAC := ratingMAC + 1
float ratingSMMA200 = na
if not na(SMMA200)
ratingSMMA200 := calcRatingMA(SMMA200, close)
ratingMA := ratingMA + ratingSMMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingLSMA10 = na
if not na(LSMA10)
ratingLSMA10 := calcRatingMA(LSMA10, close)
ratingMA := ratingMA + ratingLSMA10
ratingMAC := ratingMAC + 1
float ratingLSMA20 = na
if not na(LSMA20)
ratingLSMA20 := calcRatingMA(LSMA20, close)
ratingMA := ratingMA + ratingLSMA20
ratingMAC := ratingMAC + 1
float ratingLSMA50 = na
if not na(LSMA50)
ratingLSMA50 := calcRatingMA(LSMA50, close)
ratingMA := ratingMA + ratingLSMA50
ratingMAC := ratingMAC + 1
float ratingLSMA100 = na
if not na(LSMA100)
ratingLSMA100 := calcRatingMA(LSMA100, close)
ratingMA := ratingMA + ratingLSMA100
ratingMAC := ratingMAC + 1
float ratingLSMA200 = na
if not na(LSMA200)
ratingLSMA200 := calcRatingMA(LSMA200, close)
ratingMA := ratingMA + ratingLSMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingVWMA10 = na
if not na(VWMA10)
ratingVWMA10 := calcRatingMA(VWMA10, close)
ratingMA := ratingMA + ratingVWMA10
ratingMAC := ratingMAC + 1
float ratingVWMA20 = na
if not na(VWMA20)
ratingVWMA20 := calcRatingMA(VWMA20, close)
ratingMA := ratingMA + ratingVWMA20
ratingMAC := ratingMAC + 1
float ratingVWMA50 = na
if not na(VWMA50)
ratingVWMA50 := calcRatingMA(VWMA50, close)
ratingMA := ratingMA + ratingVWMA50
ratingMAC := ratingMAC + 1
float ratingVWMA100 = na
if not na(VWMA100)
ratingVWMA100 := calcRatingMA(VWMA100, close)
ratingMA := ratingMA + ratingVWMA100
ratingMAC := ratingMAC + 1
float ratingVWMA200 = na
if not na(VWMA200)
ratingVWMA200 := calcRatingMA(VWMA200, close)
ratingMA := ratingMA + ratingVWMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingDEMA10 = na
if not na(DEMA10)
ratingDEMA10 := calcRatingMA(DEMA10, close)
ratingMA := ratingMA + ratingDEMA10
ratingMAC := ratingMAC + 1
float ratingDEMA20 = na
if not na(DEMA20)
ratingDEMA20 := calcRatingMA(DEMA20, close)
ratingMA := ratingMA + ratingDEMA20
ratingMAC := ratingMAC + 1
float ratingDEMA50 = na
if not na(DEMA50)
ratingDEMA50 := calcRatingMA(DEMA50, close)
ratingMA := ratingMA + ratingDEMA50
ratingMAC := ratingMAC + 1
float ratingDEMA100 = na
if not na(DEMA100)
ratingDEMA100 := calcRatingMA(DEMA100, close)
ratingMA := ratingMA + ratingDEMA100
ratingMAC := ratingMAC + 1
float ratingDEMA200 = na
if not na(DEMA200)
ratingDEMA200 := calcRatingMA(DEMA200, close)
ratingMA := ratingMA + ratingDEMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
float ratingHMA10 = na
if not na(HMA10)
ratingHMA10 := calcRatingMA(HMA10, close)
ratingMA := ratingMA + ratingHMA10
ratingMAC := ratingMAC + 1
float ratingHMA20 = na
if not na(HMA20)
ratingHMA20 := calcRatingMA(HMA20, close)
ratingMA := ratingMA + ratingHMA20
ratingMAC := ratingMAC + 1
float ratingHMA50 = na
if not na(HMA50)
ratingHMA50 := calcRatingMA(HMA50, close)
ratingMA := ratingMA + ratingHMA50
ratingMAC := ratingMAC + 1
float ratingHMA100 = na
if not na(HMA100)
ratingHMA100 := calcRatingMA(HMA100, close)
ratingMA := ratingMA + ratingHMA100
ratingMAC := ratingMAC + 1
float ratingHMA200 = na
if not na(HMA200)
ratingHMA200 := calcRatingMA(HMA200, close)
ratingMA := ratingMA + ratingHMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingKAMA10 = na
if not na(KAMA10)
ratingKAMA10 := calcRatingMA(KAMA10, close)
ratingMA := ratingMA + ratingKAMA10
ratingMAC := ratingMAC + 1
float ratingKAMA20 = na
if not na(KAMA20)
ratingKAMA20 := calcRatingMA(KAMA20, close)
ratingMA := ratingMA + ratingKAMA20
ratingMAC := ratingMAC + 1
float ratingKAMA50 = na
if not na(KAMA50)
ratingKAMA50 := calcRatingMA(KAMA50, close)
ratingMA := ratingMA + ratingKAMA50
ratingMAC := ratingMAC + 1
float ratingKAMA100 = na
if not na(KAMA100)
ratingKAMA100 := calcRatingMA(KAMA100, close)
ratingMA := ratingMA + ratingKAMA100
ratingMAC := ratingMAC + 1
float ratingKAMA200 = na
if not na(KAMA200)
ratingKAMA200 := calcRatingMA(KAMA200, close)
ratingMA := ratingMA + ratingKAMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingFRAMA10 = na
if not na(FRAMA10)
ratingFRAMA10 := calcRatingMA(FRAMA10, close)
ratingMA := ratingMA + ratingFRAMA10
ratingMAC := ratingMAC + 1
float ratingFRAMA20 = na
if not na(FRAMA20)
ratingFRAMA20 := calcRatingMA(FRAMA20, close)
ratingMA := ratingMA + ratingFRAMA20
ratingMAC := ratingMAC + 1
float ratingFRAMA50 = na
if not na(FRAMA50)
ratingFRAMA50 := calcRatingMA(FRAMA50, close)
ratingMA := ratingMA + ratingFRAMA50
ratingMAC := ratingMAC + 1
float ratingFRAMA100 = na
if not na(FRAMA100)
ratingFRAMA100 := calcRatingMA(FRAMA100, close)
ratingMA := ratingMA + ratingFRAMA100
ratingMAC := ratingMAC + 1
float ratingFRAMA200 = na
if not na(FRAMA200)
ratingFRAMA200 := calcRatingMA(FRAMA200, close)
ratingMA := ratingMA + ratingFRAMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingVIDMA10 = na
if not na(VIDMA10)
ratingVIDMA10 := calcRatingMA(VIDMA10, close)
ratingMA := ratingMA + ratingVIDMA10
ratingMAC := ratingMAC + 1
float ratingVIDMA20 = na
if not na(VIDMA20)
ratingVIDMA20 := calcRatingMA(VIDMA20, close)
ratingMA := ratingMA + ratingVIDMA20
ratingMAC := ratingMAC + 1
float ratingVIDMA50 = na
if not na(VIDMA50)
ratingVIDMA50 := calcRatingMA(VIDMA50, close)
ratingMA := ratingMA + ratingVIDMA50
ratingMAC := ratingMAC + 1
float ratingVIDMA100 = na
if not na(VIDMA100)
ratingVIDMA100 := calcRatingMA(VIDMA100, close)
ratingMA := ratingMA + ratingVIDMA100
ratingMAC := ratingMAC + 1
float ratingVIDMA200 = na
if not na(VIDMA200)
ratingVIDMA200 := calcRatingMA(VIDMA200, close)
ratingMA := ratingMA + ratingVIDMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
float ratingJMA10 = na
if not na(JMA10)
ratingJMA10 := calcRatingMA(JMA10, close)
ratingMA := ratingMA + ratingJMA10
ratingMAC := ratingMAC + 1
float ratingJMA20 = na
if not na(JMA20)
ratingJMA20 := calcRatingMA(JMA20, close)
ratingMA := ratingMA + ratingJMA20
ratingMAC := ratingMAC + 1
float ratingJMA50 = na
if not na(JMA50)
ratingJMA50 := calcRatingMA(JMA50, close)
ratingMA := ratingMA + ratingJMA50
ratingMAC := ratingMAC + 1
float ratingJMA100 = na
if not na(JMA100)
ratingJMA100 := calcRatingMA(JMA100, close)
ratingMA := ratingMA + ratingJMA100
ratingMAC := ratingMAC + 1
float ratingJMA200 = na
if not na(JMA200)
ratingJMA200 := calcRatingMA(JMA200, close)
ratingMA := ratingMA + ratingJMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingTEMA10 = na
if not na(TEMA10)
ratingTEMA10 := calcRatingMA(TEMA10, close)
ratingMA := ratingMA + ratingTEMA10
ratingMAC := ratingMAC + 1
float ratingTEMA20 = na
if not na(TEMA20)
ratingTEMA20 := calcRatingMA(TEMA20, close)
ratingMA := ratingMA + ratingTEMA20
ratingMAC := ratingMAC + 1
float ratingTEMA50 = na
if not na(TEMA50)
ratingTEMA50 := calcRatingMA(TEMA50, close)
ratingMA := ratingMA + ratingTEMA50
ratingMAC := ratingMAC + 1
float ratingTEMA100 = na
if not na(TEMA100)
ratingTEMA100 := calcRatingMA(TEMA100, close)
ratingMA := ratingMA + ratingTEMA100
ratingMAC := ratingMAC + 1
float ratingTEMA200 = na
if not na(TEMA200)
ratingTEMA200 := calcRatingMA(TEMA200, close)
ratingMA := ratingMA + ratingTEMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
float ratingZLEMA10 = na
if not na(ZLEMA10)
ratingZLEMA10 := calcRatingMA(ZLEMA10, close)
ratingMA := ratingMA + ratingZLEMA10
ratingMAC := ratingMAC + 1
float ratingZLEMA20 = na
if not na(ZLEMA20)
ratingZLEMA20 := calcRatingMA(ZLEMA20, close)
ratingMA := ratingMA + ratingZLEMA20
ratingMAC := ratingMAC + 1
float ratingZLEMA50 = na
if not na(ZLEMA50)
ratingZLEMA50 := calcRatingMA(ZLEMA50, close)
ratingMA := ratingMA + ratingZLEMA50
ratingMAC := ratingMAC + 1
float ratingZLEMA100 = na
if not na(ZLEMA100)
ratingZLEMA100 := calcRatingMA(ZLEMA100, close)
ratingMA := ratingMA + ratingZLEMA100
ratingMAC := ratingMAC + 1
float ratingZLEMA200 = na
if not na(ZLEMA200)
ratingZLEMA200 := calcRatingMA(ZLEMA200, close)
ratingMA := ratingMA + ratingZLEMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
///////////////////////////
float ratingTRIMA10 = na
if not na(TRIMA10)
ratingTRIMA10 := calcRatingMA(TRIMA10, close)
ratingMA := ratingMA + ratingTRIMA10
ratingMAC := ratingMAC + 1
float ratingTRIMA20 = na
if not na(TRIMA20)
ratingTRIMA20 := calcRatingMA(TRIMA20, close)
ratingMA := ratingMA + ratingTRIMA20
ratingMAC := ratingMAC + 1
float ratingTRIMA50 = na
if not na(TRIMA50)
ratingTRIMA50 := calcRatingMA(TRIMA50, close)
ratingMA := ratingMA + ratingTRIMA50
ratingMAC := ratingMAC + 1
float ratingTRIMA100 = na
if not na(TRIMA100)
ratingTRIMA100 := calcRatingMA(TRIMA100, close)
ratingMA := ratingMA + ratingTRIMA100
ratingMAC := ratingMAC + 1
float ratingTRIMA200 = na
if not na(TRIMA200)
ratingTRIMA200 := calcRatingMA(TRIMA200, close)
ratingMA := ratingMA + ratingTRIMA200
ratingMAC := ratingMAC + 1
/////////////////////////
///////////////////////////
float ratingT3MA10 = na
if not na(T3MA10)
ratingT3MA10 := calcRatingMA(T3MA10, close)
ratingMA := ratingMA + ratingT3MA10
ratingMAC := ratingMAC + 1
float ratingT3MA20 = na
if not na(T3MA20)
ratingT3MA20 := calcRatingMA(T3MA20, close)
ratingMA := ratingMA + ratingT3MA20
ratingMAC := ratingMAC + 1
float ratingT3MA50 = na
if not na(T3MA50)
ratingT3MA50 := calcRatingMA(T3MA50, close)
ratingMA := ratingMA + ratingT3MA50
ratingMAC := ratingMAC + 1
float ratingT3MA100 = na
if not na(T3MA100)
ratingT3MA100 := calcRatingMA(T3MA100, close)
ratingMA := ratingMA + ratingT3MA100
ratingMAC := ratingMAC + 1
float ratingT3MA200 = na
if not na(T3MA200)
ratingT3MA200 := calcRatingMA(T3MA200, close)
ratingMA := ratingMA + ratingT3MA200
ratingMAC := ratingMAC + 1
//////////////////////////////////////////
float ratingIC = na
if not (na(IC_Lead1) or na(IC_Lead2) or na(close) or na(close[1]) or na(IC_BLine) or na(IC_CLine))
ratingIC := calcRating(
IC_Lead1 > IC_Lead2 and close > IC_Lead1 and close < IC_BLine and close[1] < IC_CLine and close > IC_CLine,
IC_Lead2 > IC_Lead1 and close < IC_Lead2 and close > IC_BLine and close[1] > IC_CLine and close < IC_CLine)
if not na(ratingIC)
ratingMA := ratingMA + ratingIC
ratingMAC := ratingMAC + 1
ratingMA := ratingMAC > 0 ? ratingMA / ratingMAC : na
float ratingTotal = 0
float ratingTotalC = 0
if not na(ratingMA)
ratingTotal := ratingTotal + ratingMA
ratingTotalC := ratingTotalC + 1
ratingTotal := ratingTotalC > 0 ? ratingTotal / ratingTotalC : na
[ratingTotal, ratingMA]
getSignal2(ratingTotal, ratingMA) =>
float _res = ratingTotal
_res := ratingMA
[ratingTotal, ratingMA] = request.security(syminfo.tickerid, res, calcRatingAll())
tradeSignal = getSignal2(ratingTotal, ratingMA)
rating_entry = input.float(0.95, title='Rating for long', group="Entry Rating %", step=0.05)
rating_exit = input.float(0.75, title='Rating for short', group="Entry Rating %", step=0.05) * -1
long = tradeSignal >= rating_entry
short = tradeSignal <= rating_exit
strategy.entry("long",strategy.long,when=long)
strategy.entry('short',strategy.short,when=short)
Thêm nữa
- Chiến lược đảo ngược trung bình di chuyển kép
- STC MA ATR Chiến lược giao dịch xu hướng tích hợp
- Chiến lược tăng xu hướng dựa trên chỉ số RSI ngẫu nhiên với các quy tắc đặc biệt cho sự thiên vị tăng mạnh
- Xu hướng ngắn hạn sau chiến lược dựa trên chỉ số SMA
- Xu hướng vàng/bạc 30m theo chiến lược phá vỡ
- Đánh dấu xu hướng thích nghi Chiến lược dừng lỗ
- Chiến lược giảm ngắn hạn dựa trên chỉ số EMA Crossover và Bear Power
- Chiến lược giao dịch chéo EMA kép
- Chiến lược chéo giữa hai mức trung bình động
- Chiến lược thoát hiểm 9 ngày của Williams
- Xu hướng sau chiến lược chéo trung bình động tối đa hóa
- Xu hướng theo chiến lược mua và bán
- Brin đã thay đổi chiến lược của mình để ngăn chặn và Martin Gelder đã tăng
- RSI và Moving Average Crossover Multi-Timeframe Trading Strategy
- Chiến lược kết hợp 123 đảo ngược và RSI làm mịn
- Chiến lược giao dịch chéo EMA kép
- Chiến lược đường trung tâm dừng lỗ ATR năng động
- Chiến lược giao thoa EMA kép
- Chiến lược giao dịch ngày mây Ichimoku
- Hệ thống giao dịch đòn bẩy điều chỉnh rủi ro năng động