En la carga de los recursos... Cargando...

Indicador de impulso Estrategia de negociación de decisiones

El autor:¿ Qué pasa?, Fecha: 2023-12-15 15:31:52
Las etiquetas:

Resumen general

El indicador de impulso es una estrategia de seguimiento de tendencias. Construye un indicador de impulso utilizando una media móvil exponencial doble y lo combina con el indicador de cambio de tasa de precios para generar señales comerciales. Cuando el indicador de impulso sube, genera señales largas. Cuando el indicador de impulso baja, genera señales cortas.

Principio de la estrategia

La estrategia utiliza un oscilador de punto de decisión basado en una media móvil exponencial doble para medir el impulso. Primero calcula la tasa de cambio de precios diaria, luego utiliza promedios móviles exponenciales dobles de 31 días y 20 días para suavizar la tasa de cambio de precios por separado. Finalmente, utiliza una media móvil suavizada de 9 días para emitir señales comerciales. Cuando la línea rápida está por encima de la línea lenta, indica un mercado alcista. Cuando la línea rápida está por debajo de la línea lenta, indica un mercado bajista.

La estrategia también introduce un indicador de cambio de tasa de precios para evitar señales erróneas en los mercados laterales.

Análisis de ventajas

La estrategia combina el indicador de impulso y el indicador de tasa de cambio de precios, que puede identificar efectivamente las tendencias a medio plazo y evitar la negociación frecuente en mercados volátiles.

Análisis de riesgos

La estrategia se basa principalmente en el comercio de tendencias a mediano y largo plazo, incapaz de capturar las fluctuaciones de precios a corto plazo. Cuando hay un movimiento brusco del mercado, el punto de stop loss puede romperse, lo que lleva a mayores pérdidas. Además, la configuración inadecuada de parámetros también puede afectar a la estrategia. Por ejemplo, si los parámetros de la media móvil exponencial doble se establecen demasiado cortos, la probabilidad de operaciones incorrectas aumentará.

Para evitar riesgos, los puntos de stop loss se pueden ajustar adecuadamente para ampliar el rango de stop loss. Cuando ocurre un movimiento brusco del mercado, la estrategia se puede apagar temporalmente para evitar la probabilidad de que se rompa el stop loss. Para el ajuste de parámetros, se debe realizar una prueba posterior detallada para seleccionar los parámetros óptimos.

Direcciones de optimización

La estrategia se puede optimizar en los siguientes aspectos:

Añadir otros indicadores de filtrado como el indicador de volatilidad para evitar la negociación durante los períodos de fuertes fluctuaciones del mercado.
Agregar modelos de aprendizaje automático para ayudar a juzgar la dirección y la fuerza de la tendencia, lo que puede mejorar la precisión de la señal.
Prueba diferentes indicadores de impulso como el índice de fuerza relativa, el oscilador estocástico para optimizar el tiempo de entrada y salida.
En el comercio en vivo, ajustar dinámicamente los parámetros combinados con las condiciones recientes del mercado para buscar una combinación óptima de parámetros.

Conclusión

La estrategia de negociación de decisión de indicadores de impulso es generalmente una estrategia de seguimiento de tendencias a medio y largo plazo estable. Identifica de manera efectiva las tendencias y evita operaciones incorrectas al combinar el indicador de impulso promedio móvil exponencial doble y el indicador de tasa de cambio de precios. Mientras tanto, controla el riesgo estableciendo puntos de stop loss. Si los parámetros se ajustan correctamente y los resultados de las pruebas de retroceso son buenos, es adecuado para los inversores a medio y largo plazo que buscan rendimientos excesivos. Por supuesto, los operadores aún necesitan ser conscientes del riesgo que traen las fuertes fluctuaciones del mercado a la estrategia.

/*backtest
start: 2022-12-08 00:00:00
end: 2023-11-10 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("Decision 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(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)

testPeriod() => true

/////////////// Decision ///////////////
src = input(ohlc4, title="Source")
length1 = input(31, title="First Smoothing")
length2 = input(20, title="Second Smoothing")
siglength = input(9, title="Signal Smoothing")
fr = input(true, title="Fill Region")

calc_csf(src, length) => 
	sm = 2.0 / length
	csf = 0.0
	csf := (src - nz(csf[1])) * sm + nz(csf[1])
	csf
i = (src / nz(src[1], src)) * 100
pmol2 = calc_csf(i - 100, length1)
pmol = calc_csf(10 * pmol2, length2)
pmols = ema(pmol, siglength)
d = pmol - pmols
duml = plot(fr ? (d > 0 ? pmol : pmols) : na, style=plot.style_circles, color=color.yellow, linewidth=0, title="DummyL")

hc = d > 0 ? d > d[1] ? color.lime : color.green : d < d[1] ? color.red : color.orange

///////////// Rate Of Change ///////////// 
source = close
roclength = input(30, minval=1)
pcntChange = input(7, 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 = d > 0 and isMoving() 
short = d < 0 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("Long",  strategy.long, when=long)
    strategy.entry("Short", strategy.short, when=short)
    strategy.exit("L Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
    strategy.exit("S Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)

/////////////// Plotting ///////////////
sigl = plot(false ? na : pmols, title="PMO Signal", color=color.gray, linewidth=2, title="Signal")
mdl = plot(false ? na : pmol, title="PMO", color=color.black, linewidth=2, title="PMO")
fill(duml, sigl, color.green, transp=20, title="PosFill")
fill(duml, mdl, color.red, transp=20, title="NegFill")
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)

Más.