Strategi Rata-rata Pergerakan Terobosan Spiral ke Atas
ChaoZhang
Ringkasan
Strategi ini menggabungkan indikator spiral dan indikator diferensial untuk menghasilkan sinyal beli ketika harga menembus garis orbit atas dan garis rata. Strategi ini menggunakan spiral untuk menentukan arah tren harga dan menggunakan indikator diferensial untuk mendeteksi energi harga, menghasilkan sinyal perdagangan berdasarkan dua indikator yang dikonfirmasi secara bersamaan, sehingga menghasilkan peluang yang lebih baik.
Prinsip Strategi
Strategi ini didasarkan pada dua indikator:
Saluran spiral: menghitung garis bawah, digunakan untuk menentukan arah tren harga. Ketika harga menembus tren naik naik, ketika harga menembus tren turun turun.
Rasio perbedaan indikator ((ROC): untuk mendeteksi apakah harga sedang mempercepat, digunakan untuk menilai harga dinamis. ROC lebih besar dari suatu nilai positif berarti harga meningkat dengan percepatan, dan lebih kecil dari suatu nilai negatif berarti harga menurun dengan percepatan.
Sinyal beli dihasilkan ketika spiral dan indikator diferensial mengeluarkan sinyal multi-head sekaligus. Ini berarti bahwa harga harus secara bersamaan menembus tren dan menunjukkan tanda-tanda percepatan naik. Logika yang sama juga berlaku untuk menghasilkan sinyal jual.
Kombinasi seperti itu dapat meningkatkan keandalan sinyal dan menghindari perdagangan buta tanpa tren yang jelas.
Keunggulan Strategis
Jika dilihat dari tren harga dan dinamika, sinyal lebih dapat diandalkan, dan tingkat kemenangan lebih tinggi.
Dengan mengoptimalkan parameter, frekuensi perdagangan strategi dapat disesuaikan. Misalnya, menyesuaikan parameter indikator tingkat deviasi, sehingga dapat mengontrol sensitivitas posisi terbuka.
Stop loss digunakan untuk mengendalikan kerugian tunggal. Parameter dapat disesuaikan.
Sistem re-entry dapat melacak tren dan meningkatkan profitabilitas.
Risiko Strategis
“Kalau tidak, kita akan kehilangan beberapa peluang perdagangan, dan kemampuannya untuk menghasilkan uang akan dibatasi”.
Strategi terobosan mudah terjebak. Jika harga berbalik, kemungkinan besar akan terjadi kerugian besar.
Setting parameter yang tidak tepat dapat menyebabkan sinyal perdagangan terlalu sering atau jarang.
Stop loss dengan persentase tetap tidak dapat sepenuhnya menghindari kerugian tunggal yang lebih besar.
Arah optimasi strategi
Uji parameter dari indikator laju diferensial untuk menemukan kombinasi parameter yang optimal.
Uji berbagai tingkat stop loss, keseimbangan rasio untung rugi dan rasio kemenangan.
Menambahkan filter indikator lain, seperti indikator kapasitas, indikator getaran, dan lain-lain, meningkatkan kualitas sinyal.
Untuk itu, kami akan menguji pasar yang berbeda untuk menemukan varietas yang paling cocok dengan strategi kami.
Manajemen posisi yang dioptimalkan dalam strategi, menggunakan posisi yang berbeda dalam kondisi pasar yang berbeda.
Meringkaskan
Strategi ini menggabungkan penggunaan spiral dan indikator tingkat diferensial untuk menilai tren dan dinamika harga, serta kemampuan untuk mempertahankan profitabilitas melalui re-entry dan pengoptimalan parameter sambil memastikan kualitas sinyal perdagangan. Pengendalian risiko yang didasarkan pada persentase stop loss tetap dapat dioptimalkan lebih lanjut. Secara keseluruhan, strategi ini lebih lengkap dan cocok sebagai kerangka dasar untuk perdagangan kuantitatif.
/*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)