Strategi mengikut arah aliran automatik berdasarkan titik pangsi dan anjakan Fibonacci


Tarikh penciptaan: 2024-01-05 11:34:17 Akhirnya diubah suai: 2024-01-05 11:34:17
Salin: 0 Bilangan klik: 687
1
fokus pada
1621
Pengikut

Strategi mengikut arah aliran automatik berdasarkan titik pangsi dan anjakan Fibonacci

Gambaran keseluruhan

Strategi ini secara automatik mengenal pasti gelombang ABC harga saham berdasarkan titik pivot dan nisbah pengunduran Fibonacci, dan memberi isyarat kedudukan panjang dan pendek. Strategi ini menggunakan titik pivot untuk menentukan gelombang harga saham, dan kemudian mengira nisbah pengunduran Fibonacci antara gelombang ABC, dan menghasilkan isyarat perdagangan jika memenuhi syarat tertentu.

Prinsip Strategi

  1. Mengira kedudukan tinggi dan rendah saham
  2. Menentukan sama ada harga turun dari paras tertinggi pada gelombang sebelumnya atau naik dari paras terendah pada gelombang sebelumnya
  3. Hitung nisbah pengunduran Fibonacci antara gelombang semasa dan gelombang sebelumnya
  4. Jika kadar penarikan balik dalam kedua-dua gelombang naik dan turun berada dalam julat yang sesuai, ia boleh membentuk gelombang ABC
  5. Selepas ABC band disahkan, apabila melakukan lebih banyak, tetapkan stop loss sebagai titik C, dan hentikan 1.5 kali turun naik; apabila melakukan kosong, tetapkan stop loss sebagai titik A, dan hentikan 1.5 kali turun naik

Analisis kelebihan

  1. Menggunakan titik-titik pusat untuk menentukan kawasan rintangan sokongan utama untuk meningkatkan ketepatan isyarat
  2. Aplikasi Fibonacci Retracement mengenal pasti bentuk ABC dan menangkap titik peralihan trend secara automatik
  3. Stop loss yang jelas dan munasabah untuk mengelakkan kerugian yang besar

Analisis risiko

  1. Pivot Point dan Fibonacci Retracement tidak menjamin untuk menilai titik perubahan trend dengan tepat setiap kali, dan ia boleh menyebabkan kesilapan.
  2. Hentian C dan Hentian A mungkin ditembusi, menyebabkan kerugian meningkat
  3. Parameter yang perlu dioptimumkan, contohnya, kadar Fibonacci.

Arah pengoptimuman

  1. Dapat menggabungkan lebih banyak petunjuk teknikal untuk membantu menentukan bentuk ABC, meningkatkan ketepatan isyarat
  2. Julat untuk mengoptimumkan kadar penarikan balik Fibonacci untuk menyesuaikan diri dengan lebih banyak keadaan pasaran
  3. Model yang boleh dilatih dengan kaedah pembelajaran mesin untuk menentukan bentuk ABC

ringkaskan

Strategi ini berdasarkan pada titik-titik penting untuk menentukan kawasan sokongan dan rintangan, dan menggunakan perbandingan pengunduran Fibonacci untuk mengenal pasti bentuk ABC secara automatik, memberi isyarat perdagangan posisi panjang dan pendek pada titik-titik perubahan gelombang. Logik strategi jelas dan ringkas, tetapan stop loss adalah munasabah, dapat mengawal risiko dengan berkesan. Tetapi ada juga risiko kesalahan penilaian, yang memerlukan pengoptimuman dan penambahbaikan lebih lanjut untuk menyesuaikan diri dengan lebih banyak keadaan pasaran.

Kod 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)