
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.
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.
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:
A pesar de que esta estrategia tiene un gran espacio para la optimización, también presenta algunos riesgos potenciales que deben evitarse:
De acuerdo con el análisis de riesgos mencionado anteriormente, la estrategia tiene algunas mejoras importantes:
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.
/*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)