Estrategia de trading cuantitativo de cruce de tres medias móviles + indicador William
ChaoZhang
Descripción general
Esta estrategia combina tres medias móviles suaves, un índice relativamente fuerte (RSI) y el índice de William, para identificar la dirección de la tendencia de los precios de las acciones y buscar oportunidades de entrada cuando la tendencia se invierte. Cuando las tres medias móviles más lentas se alinean hacia arriba (abajo), el RSI es superior (inferior) a 50, y aparece una señal de William hacia abajo (arriba), se hace más (hombre). El stop loss se establece como un porcentaje del precio de entrada y el stop loss se establece como un porcentaje del precio de entrada que se mueve hacia arriba.
Principio de estrategia
La estrategia utiliza tres promedios móviles lisos de diferentes períodos, que incluyen la línea rápida, la línea media y la línea lenta. Cuando la línea rápida cruza la línea media, el precio de la acción entra en una tendencia alcista; cuando la línea rápida cruza la línea media, el precio de la acción entra en una tendencia bajista.
En concreto, una vez que el precio de las acciones entra en una tendencia al alza, la estrategia espera que las siguientes cinco condiciones se cumplan simultáneamente para abrir más posiciones:
- La línea rápida, la línea media y la línea lenta están todas hacia arriba.
- El RSI es superior a 50.
- El índice de William es el siguiente:
- El precio de las acciones ha bajado.
- Actualmente no tiene ninguna posición.
Una vez que el precio de las acciones entra en una tendencia a la baja, la estrategia espera que las siguientes cinco condiciones se cumplan simultáneamente para abrir una posición en blanco:
- La línea rápida, la línea media y la línea lenta están todas hacia abajo.
- El RSI está por debajo de 50.
- El índice de William se muestra hacia arriba.
- El precio de las acciones ha bajado.
- Actualmente no tiene ninguna posición.
Después de hacer más deuda pública, la estrategia establece un punto de parada y un punto de parada para controlar el riesgo. Concretamente, el punto de parada es un cierto porcentaje del precio de entrada y el punto de parada es el precio después de que el precio de entrada se mueva en la dirección favorable.
Ventajas estratégicas
La combinación de varios indicadores de confirmación de entrada, puede evitar efectivamente la falsa ruptura. Las tres líneas uniformes determinan la dirección de la tendencia, el indicador de William capta la señal de reversión, el RSI filtra la situación de la oscilación, y juntos mejoran la precisión de la entrada.
La configuración de un punto de parada para detener la pérdida permite un buen control de la relación riesgo-beneficio de cada unidad, lo que garantiza que las operaciones rentables sean mayores que las pérdidas.
La lógica de la estrategia es clara y fácil de entender, la configuración de los parámetros es razonable y es adecuada para el uso de comerciantes de diferentes niveles.
Riesgo estratégico
En situaciones de oscilación, el indicador puede emitir una señal errónea, lo que lleva a una entrada innecesaria. Se puede filtrar parte de la oscilación mediante la optimización de los parámetros del RSI.
El cruce de la línea media rápida puede presentar falsas rupturas y debe usarse junto con otros indicadores. Se puede considerar la inclusión de un indicador de volumen de tráfico.
Si el punto de parada está demasiado cerca del precio de entrada, el punto de parada puede ser eliminado, y la configuración del punto de parada debe ajustarse a la posición adecuada.
Si el punto de parada está demasiado lejos del precio de entrada, es posible que no se pueda detener la salida, y el punto de parada debe ajustarse a la posición adecuada.
Dirección de optimización de la estrategia
Se pueden probar combinaciones de parámetros de diferentes períodos para optimizar los parámetros de las tres medias y el RSI.
Se pueden agregar otros indicadores, como el indicador de volumen de transacciones, para determinar si el volumen de transacciones es destacado antes de la ruptura.
La configuración de los parámetros de la estrategia se puede probar en diferentes variedades.
Se puede trazar una curva de ganancias en función de los resultados de la retroalimentación y se puede probar la configuración de los parámetros de parada de pérdida.
Se puede intentar realizar transacciones simuladas y optimizar la configuración de los parámetros antes de la activación.
Resumir
La estrategia en su conjunto es lógica, utiliza una combinación de indicadores para ingresar y salir, y puede controlar el riesgo de manera efectiva. El espacio para optimizar los parámetros de la estrategia es grande, y mediante la prueba de diferentes configuraciones de parámetros, la estrategia puede convertirse en una estrategia de negociación cuantitativa de ganancias estables.
/*backtest
start: 2023-08-28 00:00:00
end: 2023-09-27 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//This script is a combination of 3 smoothed moving averages, and RSI. When moving averages are aligned upward (downward) and RSI is above (below) 50 and a down (up) William fractal appears, it enters long (short) position. Exiting from long and short entries are defined by StopLoss and TargetProfit.
//@version=5
strategy(title="3SmmaCrossUp + Fractal + RSI", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100, currency=currency.USD, commission_type=strategy.commission.percent, commission_value=0.03)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// inputs
// Global
src = input(close, title="Source")
stopLoss = input.float(defval = 0.1, title = "Stop Loss %", minval = 0, maxval=100, step = 0.1)
targetProfit = input.float(defval = 0.4, title = "Target Profit %", minval = 0, maxval=100, step = 0.1)
// Smooth Moving Average
fastSmmaLen = input.int(21, minval=1, title="Fast Length", group = "Smooth Moving Average")
midSmmaLen = input.int(50, minval=1, title="Mid Length",group = "Smooth Moving Average")
slowSmmaLen = input.int(200, minval=1, title="Slow Length",group = "Smooth Moving Average")
// RSI
rsiLen = input.int(defval=14, title="length", minval=1, maxval=1000, step=1, group="RSI")
// Fractals
n = input.int(title="Periods", defval=2, minval=2, group = "Fractals")
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// initialization
var waitingFirstTradeInUpwardTrend = false
var waitingFirstTradeInDownwardTrend = false
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// functions
smma(ma, src, len) =>
smma = 0.0
smma := na(smma[1]) ? ma : (smma[1] * (len - 1) + src) / len
smma
fractals(n, highs, lows) =>
// UpFractal
bool upflagDownFrontier = true
bool upflagUpFrontier0 = true
bool upflagUpFrontier1 = true
bool upflagUpFrontier2 = true
bool upflagUpFrontier3 = true
bool upflagUpFrontier4 = true
for i = 1 to n
upflagDownFrontier := upflagDownFrontier and (highs[n-i] < highs[n])
upflagUpFrontier0 := upflagUpFrontier0 and (highs[n+i] < highs[n])
upflagUpFrontier1 := upflagUpFrontier1 and (highs[n+1] <= highs[n] and highs[n+i + 1] < highs[n])
upflagUpFrontier2 := upflagUpFrontier2 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+i + 2] < highs[n])
upflagUpFrontier3 := upflagUpFrontier3 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+i + 3] < highs[n])
upflagUpFrontier4 := upflagUpFrontier4 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+4] <= highs[n] and highs[n+i + 4] < highs[n])
flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4
upFractal = (upflagDownFrontier and flagUpFrontier)
// downFractal
bool downflagDownFrontier = true
bool downflagUpFrontier0 = true
bool downflagUpFrontier1 = true
bool downflagUpFrontier2 = true
bool downflagUpFrontier3 = true
bool downflagUpFrontier4 = true
for i = 1 to n
downflagDownFrontier := downflagDownFrontier and (lows[n-i] > lows[n])
downflagUpFrontier0 := downflagUpFrontier0 and (lows[n+i] > lows[n])
downflagUpFrontier1 := downflagUpFrontier1 and (lows[n+1] >= lows[n] and lows[n+i + 1] > lows[n])
downflagUpFrontier2 := downflagUpFrontier2 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+i + 2] > lows[n])
downflagUpFrontier3 := downflagUpFrontier3 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+i + 3] > lows[n])
downflagUpFrontier4 := downflagUpFrontier4 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+4] >= lows[n] and lows[n+i + 4] > lows[n])
flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4
downFractal = (downflagDownFrontier and flagDownFrontier)
[upFractal, downFractal]
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// calcs
[upFractal, downFractal] = fractals(n, high, low)
rsiIsHigh = ta.rsi(src, rsiLen) >= 50
slowMa = ta.sma(src, slowSmmaLen)
midMa = ta.sma(src, midSmmaLen)
fastMa = ta.sma(src, fastSmmaLen)
slowSmma = smma(slowMa ,src, slowSmmaLen)
midSmma = smma(midMa, src, midSmmaLen)
fastSmma = smma(fastMa, src, fastSmmaLen)
isFastSmmaUpward = ta.rising(fastSmma, 1)
isMidSmmaUpward = ta.rising(midSmma, 1)
isSlowSmmaUpward = ta.rising(slowSmma, 1)
isFastSmmaDownward = ta.falling(fastSmma, 1)
isMidSmmaDownward = ta.falling(midSmma, 1)
isSlowSmmaDownward = ta.falling(slowSmma, 1)
slowMovingAveragesAreUpward = isMidSmmaUpward and isSlowSmmaUpward
slowMovingAveragesAreDownward = isMidSmmaDownward and isSlowSmmaDownward
justEnteredUpwardTrend = ta.crossover(fastSmma, midSmma) ? true : false
justEnteredDownwardTrend = ta.crossunder(fastSmma, midSmma) ? true : false
waitingFirstTradeInUpwardTrend := justEnteredUpwardTrend == true ? true : (isFastSmmaDownward or isMidSmmaDownward or isSlowSmmaDownward ? false : waitingFirstTradeInUpwardTrend)
waitingFirstTradeInDownwardTrend := justEnteredDownwardTrend == true ? true : (isFastSmmaUpward or isMidSmmaUpward or isSlowSmmaUpward ? false : waitingFirstTradeInDownwardTrend)
priceCrossedOverSlowMa = ta.crossover(close, slowSmma)
priceCrossedUnderSlowMa = ta.crossunder(close, slowSmma)
enterLongCondition = barstate.isconfirmed and low > fastSmma and rsiIsHigh and (downFractal or priceCrossedOverSlowMa) and waitingFirstTradeInUpwardTrend and strategy.position_size == 0
enterShortCondition = barstate.isconfirmed and high < fastSmma and (not rsiIsHigh) and (upFractal or priceCrossedUnderSlowMa) and waitingFirstTradeInDownwardTrend and strategy.position_size == 0
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// strategy
if(enterLongCondition)
strategy.entry(id="L", direction=strategy.long)
waitingFirstTradeInUpwardTrend := false
if(enterShortCondition)
strategy.entry(id="S", direction=strategy.short)
waitingFirstTradeInDownwardTrend := false
if(strategy.position_size > 0)
strategy.exit(id="EL", stop=strategy.position_avg_price * (1 - stopLoss/100), limit=strategy.position_avg_price * (1+targetProfit/100))
if(strategy.position_size < 0)
strategy.exit(id="ES", stop=strategy.position_avg_price * (1 + stopLoss/100), limit=strategy.position_avg_price * (1-targetProfit/100))
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// plots
plot(series = slowSmma, title="Slow SMMA", linewidth=3)
plot(series = midSmma, title="Mid SMMA", linewidth=2)
plot(series = fastSmma, title="Fast SMMA", linewidth=1)
plotchar(series=rsiIsHigh, title='rsiIsHigh', char='')
plotchar(series=justEnteredUpwardTrend, title='justEnteredUpwardTrend', char='')
plotchar(series=justEnteredDownwardTrend, title='justEnteredDownwardTrend', char='')
plotchar(series=waitingFirstTradeInUpwardTrend, title='waitingFirstTradeInUpwardTrend', char='')
plotchar(series=waitingFirstTradeInDownwardTrend, title='waitingFirstTradeInDownwardTrend', char='')
plotchar(series=enterLongCondition, title='enterLongCondition' , char='')
plotchar(series=enterShortCondition, title='enterShortCondition' , char='')
plotshape(series=upFractal, title='upFractal', style=shape.triangleup, location=location.abovebar, color=#009688, size = size.tiny)
plotshape(series=downFractal, title='downFractal', style=shape.triangledown, location=location.belowbar, color=color.red, size = size.tiny)