Strategi mengikuti tren otomatis berdasarkan titik pivot dan Fibonacci retracement


Tanggal Pembuatan: 2024-01-05 11:34:17 Akhirnya memodifikasi: 2024-01-05 11:34:17
menyalin: 0 Jumlah klik: 687
1
fokus pada
1621
Pengikut

Strategi mengikuti tren otomatis berdasarkan titik pivot dan Fibonacci retracement

Ringkasan

Strategi ini secara otomatis mengidentifikasi segmen ABC dari harga saham berdasarkan pivot point dan rasio pengembalian Fibonacci, dan memberikan sinyal posisi yang lebih besar. Strategi ini menggunakan segmen pivot point untuk menentukan segmen harga saham, dan kemudian menghitung rasio pengembalian Fibonacci antara segmen ABC, yang menghasilkan sinyal perdagangan jika memenuhi persyaratan tertentu.

Prinsip Strategi

  1. Menghitung titik tinggi dan rendah pada poros saham
  2. Perhitungan apakah harga turun dari puncak gelombang sebelumnya atau naik dari titik terendah gelombang sebelumnya
  3. Hitung rasio Fibonacci retracement antara gelombang saat ini dan gelombang sebelumnya
  4. Jika rasio penarikan dari band up dan band down berada dalam kisaran yang tepat, maka dapat dipastikan bahwa band ABC terbentuk
  5. Setelah ABC band dikonfirmasi, stop loss ditetapkan sebagai titik C saat melakukan over, stop loss adalah 1,5 kali lipat; stop loss ditetapkan sebagai titik A saat melakukan over, stop loss adalah 1,5 kali lipat

Analisis Keunggulan

  1. Menggunakan titik-titik pivot untuk menentukan area resistensi pendukung utama, meningkatkan akurasi sinyal
  2. Aplikasi Fibonacci retracement untuk mengidentifikasi bentuk ABC dan secara otomatis menangkap titik-titik perubahan tren
  3. Stop loss yang jelas dan masuk akal untuk menghindari kerugian besar

Analisis risiko

  1. Pivot point dan Fibonacci retracement tidak menjamin bahwa setiap titik pergeseran tren akan diukur dengan tepat, dan mungkin terjadi kesalahan.
  2. Stop loss di titik C dan A dapat ditembus dan menyebabkan kerugian yang lebih besar.
  3. Parameter yang perlu dioptimalkan, seperti kisaran Fibonacci retracement rate

Arah optimasi

  1. Dapat digabungkan dengan lebih banyak indikator teknis untuk membantu menentukan bentuk ABC, meningkatkan akurasi sinyal
  2. Rentang Fibonacci Retracement Ratio dapat dioptimalkan untuk lebih banyak situasi pasar
  3. Model yang dapat dilatih dengan metode pembelajaran mesin untuk menentukan bentuk ABC

Meringkaskan

Strategi ini didasarkan pada pivot point untuk menentukan area resistensi pendukung utama, dan menggunakan rasio pengunduran diri Fibonacci untuk secara otomatis mengidentifikasi bentuk ABC, memberikan sinyal perdagangan posisi panjang dan pendek di titik-titik perubahan pita. Logika strategi jelas dan ringkas, pengaturan stop loss masuk akal, dan dapat mengontrol risiko secara efektif. Namun, ada risiko kesalahan penilaian tertentu, yang perlu dioptimalkan dan diperbaiki lebih lanjut untuk menyesuaikan diri dengan lebih banyak situasi pasar.

Kode Sumber Strategi
/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-19 23:59:59
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © kerok3g

//@version=5
strategy("ABCD Strategy", shorttitle="ABCDS", overlay=true, commission_value=0.04)
calcdev(fprice, lprice, fbars, lbars) =>
    rise = lprice - fprice
    run = lbars - fbars
    avg = rise/run
    ((bar_index - lbars) * avg) + lprice

len = input(5)

ph = ta.pivothigh(len, len)
pl = ta.pivotlow(len, len)

var bool ishigh = false
ishigh := ishigh[1]

var float currph = 0.0
var int currphb = 0
currph := nz(currph)
currphb := nz(currphb)

var float oldph = 0.0
var int oldphb = 0
oldph := nz(oldph)
oldphb := nz(oldphb)

var float currpl = 0.0
var int currplb = 0
currpl := nz(currpl)
currplb := nz(currplb)

var float oldpl = 0.0
var int oldplb = 0
oldpl := nz(oldpl)
oldplb := nz(oldplb)

if (not na(ph))
    ishigh := true
    oldph := currph
    oldphb := currphb
    currph := ph
    currphb := bar_index[len]
else
    if (not na(pl))
        ishigh := false
        oldpl := currpl
        oldplb := currplb
        currpl := pl
        currplb := bar_index[len]

endHighPoint = calcdev(oldph, currph, oldphb, currphb)
endLowPoint = calcdev(oldpl, currpl, oldplb, currplb)

plotshape(ph, style=shape.triangledown, color=color.red, location=location.abovebar, offset=-len)
plotshape(pl, style=shape.triangleup, color=color.green, location=location.belowbar, offset=-len)

// var line lnhigher = na
// var line lnlower = na
// lnhigher := line.new(oldphb, oldph, bar_index, endHighPoint)
// lnlower := line.new(oldplb, oldpl, bar_index, endLowPoint)
// line.delete(lnhigher[1])
// line.delete(lnlower[1])

formlong = oldphb < oldplb and oldpl < currphb and currphb < currplb
longratio1 = (currph - oldpl) / (oldph - oldpl)
longratio2 = (currph - currpl) / (currph - oldpl)

formshort = oldplb < oldphb and oldphb < currplb and currplb < currphb
shortratio1 = (oldph - currpl) / (oldph - oldpl)
shortratio2 = (currph - currpl) / (oldph - currpl)

// prevent multiple entry for one pattern
var int signalid = 0
signalid := nz(signalid[1])

longCond = formlong and 
           longratio1 < 0.7 and 
           longratio1 > 0.5 and 
           longratio2 > 1.1 and 
           longratio2 < 1.35 and 
           close < oldph and 
           close > currpl and 
           signalid != oldplb
if (longCond)
    signalid := oldplb
    longsl = currpl - ta.tr
    longtp = ((close - longsl) * 1.5) + close
    strategy.entry("Long", strategy.long)
    strategy.exit("Exit Long", "Long", limit=math.min(longtp, oldph), stop=longsl)

shortCond = formshort and 
             shortratio1 < 0.7 and 
             shortratio1 > 0.5 and 
             shortratio2 > 1.1 and 
             shortratio2 < 1.35 and 
             close > oldpl and 
             close < currph and 
             signalid != oldphb

if (shortCond)
    signalid := oldphb
    shortsl = currph + ta.tr
    shorttp = close - ((shortsl - close) * 1.5)
    strategy.entry("Short", strategy.short)
    strategy.exit("Exit Short", "Short", limit=math.max(shorttp, oldpl), stop=shortsl)