1. Quảng trường
  2. Chiến lược trung bình di chuyển đột phá xoắn ốc

Chiến lược trung bình di chuyển đột phá xoắn ốc

Tác giả:ChaoZhang, Ngày: 2024-01-15 11:45:23
Tags:

img

Tổng quan

Chiến lược này kết hợp các chỉ số kênh xoắn ốc và chỉ số tỷ lệ thay đổi (ROC). Nó tạo ra tín hiệu mua khi giá vượt qua dải trên và trung bình động, và bán tín hiệu khi giá vượt qua dải dưới và trung bình động.

Chiến lược logic

Chiến lược dựa trên hai chỉ số chính:

  1. Các kênh xoắn ốc: Chụp các dải trên và dưới để xác định hướng xu hướng. Giá phá vỡ trên dải trên cho thấy xu hướng tăng, trong khi phá vỡ bên dưới dải dưới báo hiệu xu hướng giảm.

  2. Tỷ lệ thay đổi (ROC): Khám phá sự gia tăng giá. ROC trên ngưỡng dương tính cho thấy sự gia tăng tăng giá, trong khi ROC dưới ngưỡng âm cho thấy sự gia tăng giảm giá.

Các tín hiệu mua được tạo ra khi cả kênh xoắn ốc và ROC đều đưa ra các dấu hiệu tăng, cụ thể là phá vỡ giá trên dải trên cùng với động lực tăng tốc.

Các tín hiệu kết hợp giúp tránh giao dịch chống lại xu hướng và cải thiện độ tin cậy.

Ưu điểm

  1. Các tín hiệu đáng tin cậy với tỷ lệ thắng cao hơn bằng cách yêu cầu sự đồng thuận giữa xu hướng và động lực.

  2. Tần số giao dịch có thể tùy chỉnh thông qua điều chỉnh tham số, ví dụ: điều chỉnh các tham số ROC.

  3. Dừng lỗ để hạn chế rủi ro giảm trên các giao dịch cá nhân.

  4. Nhập lại cơ chế để theo xu hướng và tăng thêm lợi nhuận.

Rủi ro

  1. Mất một số cơ hội giao dịch và hạn chế tiềm năng lợi nhuận do yêu cầu độ tin cậy tín hiệu.

  2. Thể bị mắc kẹt khi xu hướng đảo ngược, có khả năng dẫn đến tổn thất lớn.

  3. Điều chỉnh tham số kém có thể dẫn đến quá ít hoặc quá nhiều tín hiệu.

  4. Tỷ lệ dừng lỗ cố định không thể ngăn chặn tổn thất nghiêm trọng trên biến động giá bất lợi lớn.

Cơ hội gia tăng

  1. Tối ưu hóa các thông số ROC để hiệu suất tốt nhất.

  2. Kiểm tra các mức dừng lỗ khác nhau để cân bằng rủi ro và phần thưởng.

  3. Thêm các bộ lọc khác như khối lượng, chỉ số biến động để tinh chỉnh tín hiệu.

  4. Đánh giá hiệu suất trên các thị trường khác nhau để tìm phù hợp nhất.

  5. Đưa ra kích thước vị trí năng động cho các điều kiện thị trường khác nhau.

Kết luận

Chiến lược này kết hợp kênh xoắn ốc và ROC để đánh giá hướng xu hướng và động lực. Nó nhằm mục đích duy trì độ tin cậy tín hiệu trong khi duy trì lợi nhuận thông qua tái nhập và điều chỉnh tham số. Rủi ro chủ yếu được kiểm soát bằng tỷ lệ dừng lỗ cố định.

/*backtest
start: 2024-01-07 00:00:00
end: 2024-01-14 00:00:00
period: 45m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("SSL Chaikin BF 🚀", overlay=true, precision=2, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)

/////////////// Time Frame ///////////////
_0 = input(false,  "════════ Test Period ═══════")
testStartYear = input(2017, "Backtest Start Year") 
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)

testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true

/////////////// Chaikin MF /////////////// 
_1 = input(false,  "═══════ Chaikin MF ═══════")
length = input(20, minval=1, title = "Chaikin SMA Length")
upperThreshold = input(0.04, step=0.01, title="Upper Threshold")
lowerThreshold = input(0.02, step=0.01, title="Lower Threshold")
ad = close==high and close==low or high==low ? 0 : ((2*close-low-high)/(high-low))*volume
mf = sum(ad, length) / sum(volume, length)

/////////////// SSL Channels /////////////// 
_2 = input(false,  "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)

smaHigh = sma(high, len1)
smaLow = sma(low, len2)

Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh

///////////// Rate Of Change ///////////// 
_3 = input(false,  "══════ Rate of Change ══════")
source = close
roclength = input(13, "ROC Length",  minval=1)
pcntChange = input(4, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))

///////////////  Strategy  /////////////// 
long = sslUp > sslDown and isMoving() or crossover(mf, upperThreshold)
short = sslUp < sslDown and isMoving() or crossunder(mf, lowerThreshold)

last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])

long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])

last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])

in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal

last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1]) 
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) 

//////////////// Stop loss /////////////// 
_4 = input(false,  "════════ Stop Loss ═══════")
sl_inp = input(2.0, title='Stop Loss %') / 100

slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na

/////////////// Execution /////////////// 
if testPeriod()
    strategy.entry("L", strategy.long, when=long)
    strategy.entry("S", strategy.short, when=short)
    strategy.exit("L SL", "L", stop=long_sl, when=since_longEntry > 0)
    strategy.exit("S SL", "S", stop=short_sl, when=since_shortEntry > 0)

/////////////// Plotting /////////////// 
p1 = plot(sslDown, linewidth = 1, color=color.red)
p2 = plot(sslUp, linewidth = 1, color=color.lime)
fill(p1, p2,  color = sslDown < sslUp ? color.lime : color.red, transp=80)
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
bgcolor(crossover(mf, upperThreshold) ? color.blue : crossunder(mf, lowerThreshold) ? color.orange : na, transp=30)
Thêm nữa

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