Estrategia de seguimiento de tendencias de la tortuga de impulso


Fecha de creación: 2023-11-23 11:53:27 Última modificación: 2023-11-23 11:53:27
Copiar: 0 Número de Visitas: 627
1
Seguir
1617
Seguidores

Estrategia de seguimiento de tendencias de la tortuga de impulso

Descripción general

La estrategia de seguimiento de tendencias de la tormenta de movimiento es una estrategia de seguimiento de tendencias basada en las reglas de negociación de la tormenta. Utiliza el indicador de la tormenta para identificar tendencias y, en combinación con el indicador de la tormenta, filtra algunas operaciones de ruido. La principal ventaja de esta estrategia es la capacidad de capturar tendencias de precios fuertes y obtener ganancias adicionales.

Principio de estrategia

Esta estrategia utiliza el sistema de rupturas básicas en los indicadores de la tormenta para determinar la dirección de la tendencia. En concreto, cuando el precio de cierre está por encima de los máximos de los últimos 20 días, se hace más para señalar un alza; cuando el precio de cierre está por debajo de los mínimos de los últimos 20 días, se hace más para señalar una baja.

La estrategia también incluye un factor de dinámica para filtrar el ruido de las operaciones. Si el precio fluctúa menos de 5 ATR, la estrategia no entrará en operaciones.

Después de abrir la posición, la estrategia utiliza el N-valor del principio de la marea para romper la salida. Este sistema establece el punto de parada basado en los precios más altos y más bajos de los últimos 20 días. Por ejemplo, el precio de parada simple es el ATR de 2 N por debajo del precio más bajo de los últimos 20 días.

Análisis de las ventajas

La mayor ventaja de esta estrategia es que combina el seguimiento de tendencias y la gestión de la dinámica. El sistema de operaciones de piragüismo puede capturar con precisión las tendencias de precios a medio plazo y evitar ser interrumpido por el ruido del mercado. La adición del filtro de dinámica ATR puede reducir aún más el número de operaciones sin sentido, lo que aumenta considerablemente el margen de ganancia.

En concreto, esta estrategia tiene las siguientes ventajas:

  1. El indicador del tsunami es un indicador de tendencias preciso y fiable que permite un seguimiento eficaz de las tendencias a medio plazo.
  2. El mecanismo de filtración por volumen reduce las transacciones innecesarias y evita pérdidas en el número de transacciones
  3. Las medidas de control de riesgos están en su lugar para detener los pérdidas en el momento oportuno de la reversión de la tendencia
  4. En general, los parámetros de la estrategia están muy optimizados y están muy en consonancia con los principios de la playa.

Análisis de riesgos

A pesar de que esta estrategia tiene un gran espacio para la optimización, también presenta algunos riesgos potenciales que deben evitarse:

  1. No se puede resolver el problema de la exceso de volatilidad de las posiciones a largo plazo. El tamaño de la posición del sistema de tormentas no tiene en cuenta los factores de volatilidad, lo que puede conducir a pérdidas individuales excesivas.
  2. Cuando la situación cambia drásticamente, el precio de stop loss puede ser superado, lo que lleva a pérdidas mayores a las esperadas.
  3. El sistema no tiene un objetivo de ganancias, por lo que es fácil que haya un exceso de posiciones.

Dirección de optimización

De acuerdo con el análisis de riesgos mencionado anteriormente, la estrategia tiene algunas mejoras importantes:

  1. Se puede considerar la inclusión de un algoritmo de posición dinámica con ajuste de la volatilidad, de modo que se pueda reducir la posición de manera activa cuando los pérdidas de la posición alcancen un cierto margen.
  2. Aumentar el mecanismo de reversión y considerar la reducción de la posición o el vacío inverso en la formación de formas similares a la cabeza, los hombros y las dos cimas.
  3. Aumentar la meta de ganancias. Cuando las ganancias acumuladas alcanzan una cierta proporción de los activos totales de la cuenta, se puede reducir parcialmente la devolución de la posición.

Resumir

La estrategia de seguimiento de la tendencia de la tormenta dinámica en general es un programa de seguimiento de tendencias de línea media y larga muy práctico. Al mismo tiempo, combina la tendencia de juicio del indicador de la tormenta y el filtro de vibración del indicador ATR, para bloquear eficazmente las tendencias de precios fuertes. Además, el control de riesgo y la optimización de los parámetros de la estrategia también están muy bien posicionados, lo que reduce el descenso.

Código Fuente de la Estrategia
/*backtest
start: 2023-10-23 00:00:00
end: 2023-11-22 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Heiken Ashi BF 🚀", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)

/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year") 
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)

testStopYear = input(2029, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true

///////////// HA /////////////
haTicker = heikinashi(syminfo.tickerid)
haOpen = security(haTicker, "D", open)
haHigh = security(haTicker, "D", high)
haLow = security(haTicker, "D", low)
haClose = security(haTicker, "D", close)

///////////// Rate Of Change ///////////// 
source = close
roclength = input(30, minval=1)
pcntChange = input(7.0, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))

/////////////// Strategy ///////////////
long = haOpen < haClose and isMoving()
short = haOpen > haClose and isMoving()

last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])

long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)

last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])

last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])

in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal

last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])

sl_inp = input(2.0, title='Stop Loss %') / 100
tp_inp = input(5000.0, title='Take Profit %') / 100
 
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)

since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1]) 

slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na

/////////////// Execution ///////////////
if testPeriod()
    strategy.entry("L",  strategy.long, when=long)
    strategy.entry("S", strategy.short, when=short)
    strategy.exit("L SL", "L", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
    strategy.exit("S SL", "S", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)

/////////////// Plotting ///////////////
plotcandle(haOpen, haHigh, haLow, haClose, title='HA Candles', color = haOpen < haClose ? color.lime : color.red)
bgcolor(isMoving() ? long ? color.lime : short ? color.red : na : color.white, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)