Suivre la stratégie basée sur la tendance automatique basée sur les points pivots et le retracement de Fibonacci

Auteur:ChaoZhang est là., Date: 2024-01-05 11h34 et 17h
Les étiquettes:

Résumé

Cette stratégie identifie automatiquement les modèles ABC dans les cours des actions en fonction des points pivots et des ratios de retracement de Fibonacci, et génère des signaux longs/court.

La logique de la stratégie

Calculer le pivot de l'action des points hauts et bas
Jugez si le prix est tombé du point élevé précédent ou a augmenté du point bas précédent
Calculer le rapport de rétraction de Fibonacci entre la vague actuelle et la vague précédente
Si les ratios de rétraction des deux ondes vers le haut et vers le bas sont dans les limites appropriées, déterminer un modèle ABC potentiel
Après confirmation du modèle ABC, définissez un stop loss au point C pour long, et au point A pour court.

Analyse des avantages

Les points pivots identifient les principaux niveaux de support/résistance pour améliorer la précision du signal
Les retracements de Fibonacci capturent les points tournants de la tendance en identifiant les modèles ABC
Des règles claires sur les profits et les pertes évitent d'énormes pertes

Analyse des risques

Les points pivots et les retracements de Fibonacci ne peuvent pas garantir une identification parfaite de chaque tournant de tendance.
Les arrêts du point C et du point A peuvent être brisés, ce qui entraîne des pertes plus importantes
Les paramètres tels que les plages de taux de rétractation de Fibonacci nécessitent une optimisation supplémentaire

Directions d'optimisation

Incorporer plus d'indicateurs techniques pour faciliter la confirmation des modèles ABC, améliorant la précision du signal
Optimiser les plages de taux de retracement de Fibonacci pour s'adapter à davantage de conditions de marché
Utiliser des méthodes d'apprentissage automatique pour former des modèles de reconnaissance de modèles ABC

Conclusion

Cette stratégie identifie des modèles ABC pour générer des signaux longs / courts à des points tournants de la tendance, basés sur la confirmation des points pivots des niveaux de support / résistance clés et les calculs du ratio de rétraction de Fibonacci.

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

Plus de

2019 FMZ - Tous les droits réservés