Strategi perdagangan frekuensi tinggi berdasarkan dukungan dan resistensi tren super dan indikator ADX
ChaoZhang
Ringkasan
Strategi ini menggunakan garis resistensi dukungan supertrend dan indikator ADX untuk mencapai perdagangan frekuensi tinggi. Garis resistensi dukungan supertrend digunakan untuk menilai tren harga dan mengirimkan sinyal perdagangan dengan menghitung secara dinamis titik resistensi dukungan terbaru. Indikator ADX digunakan untuk menilai kekuatan tren, mengatur nilai ADX sebagai kondisi penyaringan, dan hanya mengirimkan sinyal perdagangan ketika tren cukup kuat.
Prinsip Strategi
Hitung garis resistensi dukungan. Dengan harga penutupan sebagai basis, tambahkan satu ATR ke atas dan ke bawah. Ketika harga menembus garis-garis ini, pertimbangkan untuk membalikkan tren.
Indikator ADX menilai kekuatan tren. Ketika ADX lebih tinggi dari nilai yang ditetapkan, dianggap tren cukup kuat.
Kombinasi keduanya memberikan sinyal perdagangan. Hanya jika Anda menembus garis resistensi dukungan dan ADX Anda cukup besar, Anda akan melakukan lebih banyak shorting.
Analisis Keunggulan
Strategi ini memiliki keuntungan sebagai berikut:
Perhitungan dinamis garis supertrend mendukung resistensi, dan dapat dengan cepat menilai terobosan.
Indikator ADX efektif memfilter skenario non-trending, mengurangi perdagangan tidak efektif.
Pengunduran diri dan kerugian relatif baik.
Analisis risiko
Strategi ini juga memiliki risiko sebagai berikut:
Jika Anda melakukan lompatan besar, maka garis tren super akan rusak.
ADX yang tidak tepat juga dapat mempengaruhi kinerja strategi.
Transaksi dengan frekuensi tinggi memiliki biaya transaksi yang lebih tinggi.
Solusi yang sesuai:
Optimalkan parameter super, dan relaksasi breakout amplitudo sesuai.
Tes lebih baik ADX Parameter.
Menurunkan frekuensi transaksi secara tepat.
Arah optimasi
Strategi ini dapat dioptimalkan dengan:
Optimalkan parameter ATR untuk membuat garis resistensi yang mendukung lebih kokoh.
Uji parameter ADX yang berbeda untuk menemukan nilai optimal.
Masukkan mekanisme stop loss untuk mengontrol kerugian tunggal.
Meringkaskan
Strategi ini mengintegrasikan keuntungan dari garis supertrend dan indikator ADX, dengan menghitung secara dinamis untuk mendukung resistensi dan menentukan waktu reversal tren, bekerja sama dengan indikator ADX untuk memfilter sinyal berkualitas rendah. Setelah optimasi parameter dan penyesuaian mekanisme, dapat menjadi strategi frekuensi tinggi yang menguntungkan secara stabil.
/*backtest
start: 2023-02-12 00:00:00
end: 2024-02-18 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("STPP20 + ADX", overlay = true)
///////////////////////////
// SuperTrend + Pivot Point
//////////////////////////
src = input(close, title="EMA Source")
PPprd = input(defval = 2, title="Pivot Point Period", minval = 1, maxval = 50)
AtrFactor=input(defval = 5, title = "ATR Factor", minval = 1, step = 0.1)
AtrPd=input(defval = 20, title = "ATR Period", minval=1)
float ph = na
float pl = na
ph := pivothigh(PPprd, PPprd)
pl := pivotlow(PPprd, PPprd)
float center = na
center := center[1]
float lastpp = ph ? ph : pl ? pl : na
if lastpp
if na(center)
center := lastpp
else
center := (center * 2 + lastpp) / 3
Up = center - (AtrFactor * atr(AtrPd))
Dn = center + (AtrFactor * atr(AtrPd))
float TUp = na
float TDown = na
Trend = 0
TUp := close[1] > TUp[1] ? max(Up, TUp[1]) : Up
TDown := close[1] < TDown[1] ? min(Dn, TDown[1]) : Dn
Trend := close > TDown[1] ? 1: close < TUp[1]? -1: nz(Trend[1], 1)
Trailingsl = Trend == 1 ? TUp : TDown
// Lines
linecolor = Trend == 1 and nz(Trend[1]) == 1 ? color.lime : Trend == -1 and nz(Trend[1]) == -1 ? color.red : na
plot(Trailingsl, color = linecolor , linewidth = 2, title = "PP SuperTrend")
bsignalSSPP = close > Trailingsl
ssignalSSPP = close < Trailingsl
///////
// ADX
//////
lenADX = 14
th = 25
TrueRange = max(max(high-low, abs(high-nz(close[1]))), abs(low-nz(close[1])))
DirectionalMovementPlus = high-nz(high[1]) > nz(low[1])-low ? max(high-nz(high[1]), 0): 0
DirectionalMovementMinus = nz(low[1])-low > high-nz(high[1]) ? max(nz(low[1])-low, 0): 0
SmoothedTrueRange = 0.0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1])/lenADX) + TrueRange
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1])/lenADX) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus = 0.0
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1])/lenADX) + DirectionalMovementMinus
DIPlus = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIMinus = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = abs(DIPlus-DIMinus) / (DIPlus+DIMinus)*100
ADX = sma(DX, lenADX)
//////
// MA
/////
lenMA = 21
srcMA = input(close, title="Source")
offsetMA = input(title="Offset", type=input.integer, defval=0, minval=-500, maxval=500)
outMA = sma(srcMA, lenMA)
// Buy - Sell Entries
buy = bsignalSSPP and outMA < close and ADX > th
sell = ssignalSSPP
if (buy)
// .order // Tuned version
strategy.entry("Buy", strategy.long)
if (sell) and (strategy.position_size > 0)
strategy.order("Sell", false, when = sell)