Sumber dimuat naik... memuat...
  1. Persegi
  2. Strategi Pergerakan Rata-rata Spiral Breakout

Strategi Pergerakan Rata-rata Spiral Breakout

Penulis:ChaoZhang, Tarikh: 2024-01-15 11:45:23
Tag:

img

Ringkasan

Strategi ini menggabungkan penunjuk Saluran Spiral dan penunjuk Kadar Perubahan (ROC). Ia menjana isyarat beli apabila harga menembusi jalur atas dan purata bergerak, dan isyarat jual apabila harga menembusi jalur bawah dan purata bergerak. Saluran Spiral menentukan arah trend sementara ROC mengesan momentum harga. Dengan memerlukan persetujuan antara kedua-dua penunjuk, strategi ini bertujuan untuk meningkatkan kebolehpercayaan isyarat perdagangan dan kadar kemenangan.

Logika Strategi

Strategi ini berdasarkan dua penunjuk utama:

  1. Saluran Spiral: Merangka pita atas dan bawah untuk menentukan arah trend. Harga yang pecah di atas pita atas menunjukkan trend menaik, sementara pecah di bawah pita bawah menandakan trend menurun.

  2. Kadar Perubahan (ROC): Mengesan pecutan harga. ROC di atas ambang positif menunjukkan pergerakan harga yang meningkat, sementara ROC di bawah ambang negatif menunjukkan pergerakan penurunan yang meningkat.

Isyarat beli dihasilkan apabila kedua-dua Spiral Channel dan ROC memberikan petunjuk menaik, iaitu harga menembusi band atas ditambah dengan momentum menaik yang dipercepat. Isyarat jual dipicu apabila kedua-dua penunjuk menjadi menurun.

Isyarat gabungan membantu mengelakkan perdagangan menentang trend dan meningkatkan kebolehpercayaan.

Kelebihan

  1. Isyarat yang boleh dipercayai dengan kadar kemenangan yang lebih tinggi dengan memerlukan persetujuan antara trend dan momentum.

  2. Frekuensi dagangan yang boleh disesuaikan melalui penyesuaian parameter, contohnya menyesuaikan parameter ROC.

  3. Stop loss untuk mengehadkan risiko penurunan pada perdagangan individu.

  4. Memasukkan semula mekanisme untuk menjimatkan trend dan meningkatkan keuntungan.

Risiko

  1. Melewatkan beberapa peluang perdagangan dan mengehadkan potensi keuntungan kerana keperluan kebolehpercayaan isyarat.

  2. Ringan untuk terperangkap apabila trend berbalik, berpotensi membawa kepada kerugian besar.

  3. Penyesuaian parameter yang buruk boleh mengakibatkan terlalu sedikit atau terlalu banyak isyarat.

  4. Peratusan stop loss tetap tidak dapat menghalang kerugian yang teruk pada perubahan harga yang besar.

Peluang Peningkatan

  1. Mengoptimumkan parameter ROC untuk prestasi terbaik.

  2. Uji tahap stop loss yang berbeza untuk mengimbangi risiko dan ganjaran.

  3. Tambah penapis lain seperti jumlah, penunjuk turun naik untuk memperbaiki isyarat.

  4. Menilai prestasi di pasaran yang berbeza untuk mencari yang paling sesuai.

  5. Memperkenalkan saiz kedudukan dinamik untuk keadaan pasaran yang berbeza.

Kesimpulan

Strategi ini menggabungkan Saluran Spiral dan ROC untuk menilai arah trend dan momentum. Ia bertujuan untuk kebolehpercayaan isyarat sambil mengekalkan keuntungan melalui kemasukan semula dan penyesuaian parameter. Risiko terutamanya dikawal oleh kerugian berhenti peratusan tetap. Secara keseluruhan ia adalah rangka kerja yang agak lengkap yang layak sebagai strategi perdagangan kuantitatif asas.

/*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)
Lebih lanjut

2019 FMZ - Semua hak dilindungi