Strategi perdagangan kuantitatif tiga persilangan purata bergerak + penunjuk William


Tarikh penciptaan: 2023-09-28 10:58:16 Akhirnya diubah suai: 2023-09-28 10:58:16
Salin: 1 Bilangan klik: 833
avatar of ChaoZhang ChaoZhang
1
fokus pada
1617
Pengikut

Gambaran keseluruhan

Strategi ini menggunakan gabungan tiga rata-rata bergerak rata-rata, indeks yang agak kuat (RSI) dan William, untuk mengenal pasti arah trend harga saham, mencari peluang masuk ketika trend berbalik. Apabila tiga rata-rata bergerak bergerak ke atas (RSI) sejajar, RSI lebih tinggi (RSI) daripada (RSI) 50, dan muncul tanda William ke bawah (RSI) ke atas, lakukan lebih banyak (RSI) kosong.

Prinsip Strategi

Strategi ini menggunakan rata-rata bergerak yang licin dalam tiga kitaran yang berbeza, termasuk garis cepat, garis tengah, dan garis perlahan. Apabila ia melintasi garis tengah, ia menunjukkan bahawa harga saham berada dalam trend naik; apabila ia melintasi garis tengah, ia menunjukkan bahawa harga saham berada dalam trend turun.

Khususnya, apabila harga saham memasuki trend menaik, strategi ini akan menunggu sehingga lima syarat berikut dipenuhi, sebelum membuka lebih banyak kedudukan:

  1. Garis laju, tengah dan perlahan, semuanya ke atas.
  2. RSI melebihi 50;
  3. Ia adalah bentuk William yang diletakkan ke bawah.
  4. Harga saham naik secara perlahan;
  5. Tiada pegangan.

Selepas harga saham memasuki trend menurun, strategi akan menunggu lima syarat berikut untuk memenuhi sebelum membuka posisi shorting:

  1. Garis laju, tengah dan perlahan semuanya ke bawah.
  2. RSI kurang daripada 50;
  3. Ia adalah satu bentuk yang lebih tinggi daripada yang lain.
  4. Harga saham turun secara perlahan.
  5. Tiada pegangan.

Selepas melakukan penutupan tambahan, strategi akan menetapkan titik berhenti dan titik berhenti untuk mengawal risiko. Secara khusus, titik berhenti adalah peratusan tertentu dari harga masuk dan titik berhenti adalah harga selepas harga masuk bergerak ke arah yang menguntungkan.

Kelebihan Strategik

  1. Gabungan pelbagai penunjuk untuk mengesahkan masuk, dapat menghalang penembusan palsu secara berkesan. Tiga garis lurus menentukan arah trend, penunjuk William menangkap isyarat pembalikan, RSI menapis keadaan gegaran, bersama-sama meningkatkan ketepatan masuk.

  2. Tetapkan titik hentian dan hentian, anda boleh mengawal risiko dan ganjaran setiap unit dengan baik, untuk memastikan perdagangan yang menguntungkan lebih besar daripada perdagangan yang rugi.

  3. Logik strategi jelas dan mudah difahami, parameter yang ditetapkan adalah munasabah, sesuai untuk digunakan oleh pelbagai peringkat peniaga.

Risiko Strategik

  1. Dalam keadaan goyah, penunjuk mungkin menghantar isyarat yang salah, yang menyebabkan masuk yang tidak perlu. Anda boleh menyaring beberapa keadaan goyah dengan mengoptimumkan parameter RSI.

  2. Penyelesaian yang cepat dan tepat mungkin menyebabkan penembusan palsu, dan ia harus digunakan bersama-sama dengan petunjuk lain. Anda boleh mempertimbangkan untuk memasukkan petunjuk jumlah pesanan.

  3. Stop loss yang terlalu dekat dengan harga masuk boleh menyebabkan stop loss keluar, dan penyetempatan stop loss perlu disesuaikan dengan kedudukan yang sesuai.

  4. Hentian yang terlalu jauh dari harga tiket mungkin tidak dapat menghentikan tiket keluar, dan hentian perlu disesuaikan dengan kedudukan yang sesuai.

Arah pengoptimuman strategi

  1. Anda boleh menguji kombinasi parameter untuk tempoh yang berbeza, mengoptimumkan tiga garis purata dan parameter RSI.

  2. Anda boleh menambah petunjuk lain, seperti petunjuk jumlah transaksi, untuk menilai apakah jumlah transaksi menonjol sebelum penembusan.

  3. Tetapan parameter untuk strategi ini boleh diuji mengikut jenis yang berbeza.

  4. Kurva keuntungan boleh dipetakan berdasarkan hasil pengukuran dan tetapan parameter henti rugi boleh diuji.

  5. Anda boleh mencuba perdagangan simulasi sebelum memulakan, mengoptimumkan parameter.

ringkaskan

Strategi ini secara keseluruhan logiknya jelas, menggunakan kombinasi indikator untuk masuk dan keluar, dan dapat mengawal risiko dengan berkesan. Terdapat ruang yang luas untuk mengoptimumkan parameter strategi, dan dengan menguji pelbagai tetapan parameter, strategi ini dapat menjadi strategi perdagangan kuantitatif yang menguntungkan secara stabil.

Kod sumber strategi 
/*backtest
start: 2023-08-28 00:00:00
end: 2023-09-27 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//This script is a combination of 3 smoothed moving averages, and RSI. When moving averages are aligned upward (downward) and RSI is above (below) 50 and a down (up) William fractal appears, it enters long (short) position. Exiting from long and short entries are defined by StopLoss and TargetProfit.

//@version=5

strategy(title="3SmmaCrossUp + Fractal + RSI", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100, currency=currency.USD, commission_type=strategy.commission.percent, commission_value=0.03)

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// inputs

// Global
src = input(close, title="Source")
stopLoss = input.float(defval = 0.1, title = "Stop Loss %", minval = 0, maxval=100, step = 0.1)
targetProfit = input.float(defval = 0.4, title = "Target Profit %", minval = 0, maxval=100, step = 0.1)

// Smooth Moving Average
fastSmmaLen = input.int(21, minval=1, title="Fast Length", group = "Smooth Moving Average")
midSmmaLen = input.int(50, minval=1, title="Mid Length",group = "Smooth Moving Average")
slowSmmaLen = input.int(200, minval=1, title="Slow Length",group = "Smooth Moving Average")

// RSI
rsiLen = input.int(defval=14, title="length", minval=1, maxval=1000, step=1, group="RSI")

// Fractals
n = input.int(title="Periods", defval=2, minval=2, group = "Fractals")

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// initialization

var waitingFirstTradeInUpwardTrend = false
var waitingFirstTradeInDownwardTrend = false

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// functions

smma(ma, src, len) => 
    smma = 0.0
    smma := na(smma[1]) ? ma : (smma[1] * (len - 1) + src) / len
    smma
    
fractals(n, highs, lows) =>
    // UpFractal
    bool upflagDownFrontier = true
    bool upflagUpFrontier0 = true
    bool upflagUpFrontier1 = true
    bool upflagUpFrontier2 = true
    bool upflagUpFrontier3 = true
    bool upflagUpFrontier4 = true
    for i = 1 to n
        upflagDownFrontier := upflagDownFrontier and (highs[n-i] < highs[n])
        upflagUpFrontier0 := upflagUpFrontier0 and (highs[n+i] < highs[n])
        upflagUpFrontier1 := upflagUpFrontier1 and (highs[n+1] <= highs[n] and highs[n+i + 1] < highs[n])
        upflagUpFrontier2 := upflagUpFrontier2 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+i + 2] < highs[n])
        upflagUpFrontier3 := upflagUpFrontier3 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+i + 3] < highs[n])
        upflagUpFrontier4 := upflagUpFrontier4 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+4] <= highs[n] and highs[n+i + 4] < highs[n])
    flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4
    
    upFractal = (upflagDownFrontier and flagUpFrontier)
    
    // downFractal
    bool downflagDownFrontier = true
    bool downflagUpFrontier0 = true
    bool downflagUpFrontier1 = true
    bool downflagUpFrontier2 = true
    bool downflagUpFrontier3 = true
    bool downflagUpFrontier4 = true
    
    for i = 1 to n
        downflagDownFrontier := downflagDownFrontier and (lows[n-i] > lows[n])
        downflagUpFrontier0 := downflagUpFrontier0 and (lows[n+i] > lows[n])
        downflagUpFrontier1 := downflagUpFrontier1 and (lows[n+1] >= lows[n] and lows[n+i + 1] > lows[n])
        downflagUpFrontier2 := downflagUpFrontier2 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+i + 2] > lows[n])
        downflagUpFrontier3 := downflagUpFrontier3 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+i + 3] > lows[n])
        downflagUpFrontier4 := downflagUpFrontier4 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+4] >= lows[n] and lows[n+i + 4] > lows[n])
    flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4
    
    downFractal = (downflagDownFrontier and flagDownFrontier)
    [upFractal, downFractal]

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// calcs

[upFractal, downFractal] = fractals(n, high, low)


rsiIsHigh = ta.rsi(src, rsiLen) >= 50 


slowMa = ta.sma(src, slowSmmaLen)
midMa = ta.sma(src, midSmmaLen)
fastMa = ta.sma(src, fastSmmaLen)

slowSmma = smma(slowMa ,src, slowSmmaLen)
midSmma = smma(midMa, src, midSmmaLen)
fastSmma = smma(fastMa, src, fastSmmaLen)

isFastSmmaUpward = ta.rising(fastSmma, 1)
isMidSmmaUpward = ta.rising(midSmma, 1)
isSlowSmmaUpward = ta.rising(slowSmma, 1)

isFastSmmaDownward = ta.falling(fastSmma, 1)
isMidSmmaDownward = ta.falling(midSmma, 1)
isSlowSmmaDownward = ta.falling(slowSmma, 1)

slowMovingAveragesAreUpward = isMidSmmaUpward and isSlowSmmaUpward
slowMovingAveragesAreDownward = isMidSmmaDownward and isSlowSmmaDownward

justEnteredUpwardTrend = ta.crossover(fastSmma, midSmma) ? true : false
justEnteredDownwardTrend = ta.crossunder(fastSmma, midSmma) ? true : false

waitingFirstTradeInUpwardTrend := justEnteredUpwardTrend == true ? true : (isFastSmmaDownward or isMidSmmaDownward or isSlowSmmaDownward ? false : waitingFirstTradeInUpwardTrend)
waitingFirstTradeInDownwardTrend := justEnteredDownwardTrend == true ? true : (isFastSmmaUpward or isMidSmmaUpward or isSlowSmmaUpward ? false : waitingFirstTradeInDownwardTrend)

priceCrossedOverSlowMa = ta.crossover(close, slowSmma)
priceCrossedUnderSlowMa = ta.crossunder(close, slowSmma)

enterLongCondition = barstate.isconfirmed and low > fastSmma and rsiIsHigh and (downFractal or priceCrossedOverSlowMa) and waitingFirstTradeInUpwardTrend and strategy.position_size == 0

enterShortCondition = barstate.isconfirmed and high < fastSmma and (not rsiIsHigh) and (upFractal or priceCrossedUnderSlowMa) and waitingFirstTradeInDownwardTrend and strategy.position_size == 0

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// strategy

if(enterLongCondition)
    strategy.entry(id="L", direction=strategy.long)
    waitingFirstTradeInUpwardTrend := false

if(enterShortCondition)
    strategy.entry(id="S", direction=strategy.short)
    waitingFirstTradeInDownwardTrend := false
    
if(strategy.position_size > 0)
    strategy.exit(id="EL", stop=strategy.position_avg_price * (1 - stopLoss/100), limit=strategy.position_avg_price * (1+targetProfit/100)) 
if(strategy.position_size < 0)
    strategy.exit(id="ES", stop=strategy.position_avg_price * (1 + stopLoss/100), limit=strategy.position_avg_price * (1-targetProfit/100)) 

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// plots

plot(series = slowSmma, title="Slow SMMA", linewidth=3)
plot(series = midSmma, title="Mid SMMA", linewidth=2)
plot(series = fastSmma, title="Fast SMMA", linewidth=1)
plotchar(series=rsiIsHigh, title='rsiIsHigh', char='')
plotchar(series=justEnteredUpwardTrend, title='justEnteredUpwardTrend', char='')
plotchar(series=justEnteredDownwardTrend, title='justEnteredDownwardTrend', char='')
plotchar(series=waitingFirstTradeInUpwardTrend, title='waitingFirstTradeInUpwardTrend', char='')
plotchar(series=waitingFirstTradeInDownwardTrend, title='waitingFirstTradeInDownwardTrend', char='')
plotchar(series=enterLongCondition, title='enterLongCondition' , char='')
plotchar(series=enterShortCondition, title='enterShortCondition' , char='')
plotshape(series=upFractal, title='upFractal', style=shape.triangleup, location=location.abovebar, color=#009688, size = size.tiny)
plotshape(series=downFractal, title='downFractal', style=shape.triangledown, location=location.belowbar, color=color.red, size = size.tiny)
Forums
PINE Language FAQ Summary MyLanguage Web3 About Us
Product
Robot Strategy Node Platforms Tickets
API
Syntax guide User guide Trading api Blockchain Indicator

© 2015 - ∞ INVENTOR PTE LTD (SG)