
Este artículo presenta una estrategia de negociación de ruptura dinámica basada en la forma de la línea K. La estrategia determina la tendencia del mercado y el momento de entrada mediante la identificación de la forma de la barra.
La estrategia de ruptura de la dinámica se basa principalmente en la evaluación de posibles señales de reversión, que se introducen en el campo mediante la identificación de formas de avalancha múltiple o de avalancha aérea. Una vez que se identifica la señal, se sigue rápidamente la tendencia y se obtiene un beneficio adicional.
La lógica de juicio central de la estrategia de movimiento de ruptura se basa en la identificación de las formas de avalancha, que se dividen en avalanchas de múltiples cabezas y de cabezas vacías.
Un avance múltiple es cuando el precio de cierre es más alto que el precio de apertura, y el precio de cierre de la línea K anterior es menor que el precio de apertura de la línea K anterior. Esta forma de avance suele indicar un cambio en el estado de ánimo del mercado y un cambio en la psicología de la bolsa, por lo que es un buen momento para un seguimiento adecuado.
La absorción de la cabeza vacía es exactamente lo contrario de la absorción de la cabeza múltiple, es decir, el precio de cierre del día es inferior al precio de apertura, y el precio de cierre de la línea K anterior es superior al precio de apertura de la línea K anterior. Esto también indica un cambio en la emoción del mercado y, por lo tanto, es una oportunidad para la intervención de la cabeza vacía.
Una vez identificada la forma de absorción, la estrategia de ruptura dinámica establece posiciones rápidamente, logra el exceso de apalancamiento y rastrea la potencial tendencia de reversión. Además, la estrategia también ajusta dinámicamente el precio de parada y el precio de parada, controlando estrictamente el riesgo mientras garantiza la ganancia.
En cuanto a los riesgos, se puede optimizar en los siguientes aspectos:
Las estrategias de ruptura de la dinámica se pueden optimizar en las siguientes dimensiones:
Verificación multifactorial de la fiabilidad de la señal Se pueden agregar indicadores como la línea media, la tasa de oscilación para verificar la señal de absorción y garantizar la fiabilidad de la señal.
Indicadores emocionales para juzgar el estado de ánimo del mercado La combinación de un índice de pánico y un índice de avaricia en el mercado, que son indicadores de juicio emocional, permite determinar con mayor precisión el momento en que el mercado cambia de rumbo.
Optimización de las estrategias de stop loss Se pueden bloquear las ganancias para reducir el riesgo de retiro mediante el stop loss móvil, el stop stop progresivo y el stop stop móvil.
Introducción de las operaciones algorítmicas Los modelos de algoritmos como el aprendizaje automático pueden ayudar a juzgar las señales de negociación y aumentar la automatización de las estrategias.
En general, la estrategia de ruptura de impulso es una estrategia de inversión más típica. Se invierte capturando señales clave de la línea K, juzgando rápidamente y siguiendo la tendencia del mercado. Aunque todavía existe cierto riesgo, se puede optimizar de manera efectiva de varias maneras, controlando el riesgo de ganancias en un rango razonable y adecuado para los inversores activamente emprendedores.
/*backtest
start: 2022-11-27 00:00:00
end: 2023-11-09 05:20:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
strategy(title = "MomGulfing", shorttitle = "MomGulfing", overlay = true, initial_capital=10000, pyramiding=3, calc_on_order_fills=false, calc_on_every_tick=false, currency="USD", default_qty_type=strategy.cash, default_qty_value=1000, commission_type=strategy.commission.percent, commission_value=0.04)
syear = input(2021)
smonth = input(1)
sday = input(1)
fyear = input(2022)
fmonth = input(12)
fday = input(31)
start = timestamp(syear, smonth, sday, 01, 00)
finish = timestamp(fyear, fmonth, fday, 23, 59)
date = time >= start and time <= finish ? true : false
longs = input(true)
shorts = input(true)
rr = input(2.5)
position_risk_percent = input(1)/100
signal_bar_check = input.string(defval="3", options=["1", "2", "3"])
margin_req = input(80)
sl_increase_factor = input(0.2)
tp_decrease_factor = input(0.0)
check_for_volume = input(true)
var long_sl = 0.0
var long_tp = 0.0
var short_sl = 0.0
var short_tp = 0.0
var long_lev = 0.0
var short_lev = 0.0
initial_capital = strategy.equity
position_risk = initial_capital * position_risk_percent
bullishEngulfing_st = close[1] < open[1] and close > open and high[1] < close and (check_for_volume ? volume[1]<volume : true)
bullishEngulfing_nd = close[2] < open[2] and close[1] > open[1] and close > open and high[2] > close[1] and high[2] < close and (check_for_volume ? volume[2]<volume : true)
bullishEngulfing_rd = close[3] < open[3] and close[2] > open[2] and close[1] > open[1] and close > open and high[3] > close[2] and high[3] > close[1] and high[3] < close and (check_for_volume ? volume[3]<volume : true)
bullishEngulfing = signal_bar_check == "1" ? bullishEngulfing_st : signal_bar_check == "2" ? bullishEngulfing_st or bullishEngulfing_nd : bullishEngulfing_st or bullishEngulfing_nd or bullishEngulfing_rd
long_stop_level = bullishEngulfing_st ? math.min(low[1], low) : bullishEngulfing_nd ? math.min(low[2], low[1], low) : bullishEngulfing_rd ? math.min(low[3], low[2], low[1], low) : na
rr_amount_long = close-long_stop_level
long_exit_level = close + rr*rr_amount_long
long_leverage = math.floor(margin_req/math.floor((rr_amount_long/close)*100))
bearishEngulfing_st = close[1] > open[1] and close < open and low[1] > close and (check_for_volume ? volume[1]<volume : true)
bearishEngulfing_nd = close[2] > open[2] and close[1] < open[1] and close < open and low[2] < close[1] and low[2] > close and (check_for_volume ? volume[2]<volume : true)
bearishEngulfing_rd = close[3] > open[3] and close[2] < open[2] and close[1] < open[1] and close < open and low[3] < close[2] and low[3] < close[1] and low[3] > close and (check_for_volume ? volume[3]<volume : true)
bearishEngulfing = signal_bar_check == "1" ? bearishEngulfing_st : signal_bar_check == "2" ? bearishEngulfing_st or bearishEngulfing_nd : bearishEngulfing_st or bearishEngulfing_nd or bearishEngulfing_rd
short_stop_level = bearishEngulfing_st ? math.max(high[1], high) : bearishEngulfing_nd ? math.max(high[2], high[1], high) : bearishEngulfing_rd ? math.max(high[3], high[2], high[1], high) : na
rr_amount_short = short_stop_level-close
short_exit_level = close - rr*rr_amount_short
short_leverage = math.floor(margin_req/math.floor((rr_amount_short/short_stop_level)*100))
long = longs and date and bullishEngulfing
short = shorts and date and bearishEngulfing
bgcolor(long[1] ? color.new(color.teal, 80) : (short[1] ? color.new(color.purple, 80) : na))
if long and strategy.position_size <= 0
long_lev := long_leverage
if short and strategy.position_size >= 0
short_lev := short_leverage
long_pos_size = long_lev * position_risk
long_pos_qty = long_pos_size/close
short_pos_size = short_lev * position_risk
short_pos_qty = short_pos_size/close
if long
if strategy.position_size <= 0
long_sl := long_stop_level
long_tp := long_exit_level
else if strategy.position_size > 0
long_sl := long_stop_level + sl_increase_factor*rr_amount_long
long_tp := long_exit_level - tp_decrease_factor*rr_amount_long
strategy.entry("L"+str.tostring(long_lev)+"X", strategy.long, qty=long_pos_qty)
label_text = str.tostring(long_lev)+"X\nSL:"+str.tostring(long_sl)+"\nTP:"+str.tostring(long_tp)
label.new(bar_index+1, na, text=label_text, color=color.green, style=label.style_label_up, xloc=xloc.bar_index, yloc=yloc.belowbar)
else if short
if strategy.position_size >= 0
short_sl := short_stop_level
short_tp := short_exit_level
else if strategy.position_size < 0
short_sl := short_stop_level - sl_increase_factor*rr_amount_short
short_tp := short_exit_level + tp_decrease_factor*rr_amount_short
strategy.entry("S"+str.tostring(short_lev)+"X", strategy.short, qty=short_pos_qty)
label_text = str.tostring(short_lev)+"X\nSL:"+str.tostring(short_sl)+"\nTP:"+str.tostring(short_tp)
label.new(bar_index+1, na, text=label_text, color=color.red, style=label.style_label_down, xloc=xloc.bar_index, yloc=yloc.abovebar)
if (strategy.position_size > 0)
strategy.exit(id="L TP/SL", stop=long_sl, limit=long_tp)
if (strategy.position_size < 0)
strategy.exit(id="S TP/SL", stop=short_sl, limit=short_tp)
sl_level = strategy.position_size > 0 ? long_sl : strategy.position_size < 0 ? short_sl : na
plot(sl_level, color=color.red, style=plot.style_linebr)
tp_level = strategy.position_size > 0 ? long_tp : strategy.position_size < 0 ? short_tp : na
plot(tp_level, color=color.green, style=plot.style_linebr)