Estrategia de seguimiento de tendencias automatizada basada en puntos pivote y retrocesos de Fibonacci


Fecha de creación: 2024-01-05 11:34:17 Última modificación: 2024-01-05 11:34:17
Copiar: 0 Número de Visitas: 687
1
Seguir
1621
Seguidores

Estrategia de seguimiento de tendencias automatizada basada en puntos pivote y retrocesos de Fibonacci

Descripción general

La estrategia identifica automáticamente el segmento ABC del precio de la acción basado en el eje central y el índice de retracción de Fibonacci, y da una señal de posición larga y corta. La estrategia utiliza el eje central para determinar el segmento de precio de la acción, y luego calcula el índice de retracción de Fibonacci entre los segmentos ABC, lo que genera una señal de negociación si se cumplen ciertas condiciones.

Principio de estrategia

  1. Calcular los puntos altos y bajos del eje central de las acciones
  2. Determinar si el precio ha bajado desde el punto más alto de la ola anterior o si ha subido desde el punto más bajo de la ola anterior
  3. Calcula el índice de retracción de Fibonacci entre la onda actual y la anterior
  4. Si la proporción de retroceso de las bandas de subida y bajada está dentro del rango apropiado, se determina que puede formarse una banda ABC
  5. Después de la confirmación de la banda ABC, el stop loss se establece en el punto C para hacer más, el stop loss es de 1.5 veces la oscilación; el stop loss se establece en el punto A para hacer menos, el stop loss es de 1.5 veces la oscilación

Análisis de las ventajas

  1. Utiliza los puntos centrales para determinar las áreas de resistencia de soporte clave y mejorar la precisión de la señal
  2. Aplicación de retroceso de Fibonacci para reconocer el ABC y capturar automáticamente los puntos de cambio de tendencia
  3. El Stop Loss es claro y razonable para evitar grandes pérdidas

Análisis de riesgos

  1. Los puntos cardinales y las retracciones de Fibonacci no garantizan que cada cambio de tendencia se juzgue con precisión, lo que puede ocasionar errores.
  2. Los puntos C y A de los puntos de parada podrían romperse, lo que provocaría una expansión de los daños.
  3. Optimización de parámetros, como el rango de la tasa de retiro de Fibonacci

Dirección de optimización

  1. Se puede combinar con más indicadores técnicos para ayudar a determinar la forma ABC, para mejorar la precisión de la señal
  2. El rango de la tasa de retiro de Fibonacci se puede optimizar para adaptarse a más situaciones de mercado
  3. Modelos que pueden combinarse con métodos de aprendizaje automático para determinar la forma ABC

Resumir

La estrategia se basa en la determinación de las áreas de resistencia de soporte clave en los puntos centrales, y utiliza el índice de retracción de Fibonacci para identificar automáticamente la forma ABC y dar una señal de negociación de posiciones largas y cortas en los puntos de cambio de banda. La lógica de la estrategia es clara y concisa, el parón de parada y pérdida es razonable y puede controlar el riesgo de manera efectiva. Sin embargo, también existe un cierto riesgo de error de juicio que requiere una optimización y mejora adicionales para adaptarse a más situaciones de mercado.

Código Fuente de la Estrategia
/*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)