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

Heiken Ashi y la estrategia de Super Tendencia

El autor:¿ Qué pasa?, Fecha: 2023-11-02 16:15:18
Las etiquetas:

img

Resumen general

La estrategia Heiken Ashi y Super Trend es una estrategia de seguimiento de tendencias que combina las velas Heiken Ashi y el indicador Super Trend.

Estrategia lógica

Las velas Heiken Ashi son un tipo especial de candelabros que utilizan el promedio de los precios abiertos, cerrados, altos y bajos para trazar los cuerpos de las velas, filtrando el ruido del mercado y haciendo el patrón más claro.

La estrategia primero calcula las velas de Heiken Ashi, luego calcula el indicador de Super Tendencia basado en las velas de Heiken Ashi. Las señales comerciales se generan cuando el precio rompe las líneas de Super Tendencia. Específicamente, la estrategia utiliza velas de Heiken Ashi para calcular el rango verdadero, luego deriva las bandas superior e inferior de Super Tendencia utilizando el rango y el precio promedio. Las señales largas se generan cuando el precio rompe por encima de la banda inferior, y las señales cortas cuando el precio rompe por debajo de la banda superior.

Los parámetros de Super Trend también están optimizados para obtener los mejores resultados, mejorando la sensibilidad del indicador.

Análisis de ventajas

  • Las velas Heiken Ashi filtran el ruido para señales más claras.
  • Super Trend detecta rápidamente los cambios de tendencia y genera señales oportunas.
  • La optimización de parámetros mejora la fiabilidad del indicador.
  • El mecanismo de stop loss incorporado controla eficazmente los riesgos.
  • Alto grado de automatización mediante la combinación de seguimiento de tendencias y operaciones automatizadas.

Análisis de riesgos

  • La alta automatización requiere una estrecha vigilancia para evitar anomalías.
  • Heiken Ashi puede perder señales de reversión muy pequeñas al filtrar el ruido.
  • Super Trend puede generar señales falsas, causando una entrada prematura o un stop loss.
  • La colocación incorrecta de stop loss también puede conducir a pérdidas innecesarias.
  • Los resultados en vivo pueden desviarse significativamente de los resultados de las pruebas previas.

Direcciones de optimización

  • Prueba más combinaciones de parámetros para optimizar aún más Super Trend.
  • Añadir otros indicadores para confirmar las señales de Super Tendencia y reducir las señales falsas.
  • Optimice la estrategia de stop loss para minimizar las paradas innecesarias mientras bloquea las ganancias.
  • Incorporar algoritmos de aprendizaje automático para entrenar el juicio de las tendencias reales utilizando big data.
  • Utilice marcos de tiempo más largos y datos históricos más diversos para las pruebas de retroceso para mejorar la confiabilidad.

Resumen de las actividades

La estrategia Heiken Ashi y Super Trend es una estrategia de seguimiento de tendencias. Identifica la dirección de la tendencia y opera con la tendencia principal, mientras se detiene rápidamente en las reversiones. La estrategia integra el filtro de ruido de Heiken Ashi y la detección rápida de cambios de tendencia de Super Trend. La optimización de parámetros y el diseño de stop loss permiten maximizar los retornos mientras se controlan los riesgos. Las optimizaciones futuras pueden incluir mayor ajuste de parámetros, confirmación de señales adicionales, datos de backtesting expandidos, etc. para mejorar la estabilidad y confiabilidad de la estrategia.


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

//@version=5

strategy("Heiken Ashi & Super Trend_ARM", overlay=true,  pyramiding=1,initial_capital = 10000, default_qty_type= strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills=false, slippage=0,commission_type=strategy.commission.percent,commission_value=0.02)

///////////////////////////////////////////////////
////////////////////Function///////////////////////
///////////////////////////////////////////////////


heikinashi_open = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, open)
heikinashi_high = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, high)
heikinashi_low  = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, low)
heikinashi_close= request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close)
heikinashi_color = heikinashi_open < heikinashi_close ? #53b987 : #eb4d5c
// plotbar(heikinashi_open, heikinashi_high, heikinashi_low, heikinashi_close, color=heikinashi_color)

x_sma(x, y) =>
    sumx = 0.0
    for i = 0 to y - 1
        sumx := sumx + x[i] / y
    sumx

x_rma(src, length) =>
	alpha = 1/length
	sum = 0.0
	sum := na(sum[1]) ? x_sma(src, length) : alpha * src + (1 - alpha) * nz(sum[1])

x_atr(length) =>
    trueRange = na(heikinashi_high[1])? heikinashi_high-heikinashi_low : math.max(math.max(heikinashi_high - heikinashi_low, math.abs(heikinashi_high - heikinashi_close[1])), math.abs(heikinashi_low - heikinashi_close[1]))
    //true range can be also calculated with ta.tr(true)
    x_rma(trueRange, length)

x_supertrend(factor, atrPeriod) =>
	src = (heikinashi_high+heikinashi_low)/2
	atr = x_atr(atrPeriod)
	upperBand = src + factor * atr
	lowerBand = src - factor * atr
	prevLowerBand = nz(lowerBand[1])
	prevUpperBand = nz(upperBand[1])

	lowerBand := lowerBand > prevLowerBand or heikinashi_close[1] < prevLowerBand ? lowerBand : prevLowerBand
	upperBand := upperBand < prevUpperBand or heikinashi_close[1] > prevUpperBand ? upperBand : prevUpperBand
	int direction = na
	float superTrend = na
	prevSuperTrend = superTrend[1]
	if na(atr[1])
		direction := 1
	else if prevSuperTrend == prevUpperBand
		direction := heikinashi_close > upperBand ? -1 : 1
	else
		direction := heikinashi_close < lowerBand ? 1 : -1
	superTrend := direction == -1 ? lowerBand : upperBand
	[superTrend, direction]
	

///////////////////////////////////////////////////
////////////////////Indicators/////////////////////
///////////////////////////////////////////////////

factor = input.float(3.0, "Factor", step = 0.01)
atrPeriod = input(10, "ATR Length")


[supertrend, direction] = x_supertrend(factor, atrPeriod)

bodyMiddle = plot((heikinashi_open + heikinashi_close) / 2, display=display.none)
upTrend = plot(direction < 0 ? supertrend : na, "Up Trend", color = color.green, style=plot.style_linebr)
downTrend = plot(direction < 0? na : supertrend, "Down Trend", color = color.red, style=plot.style_linebr)

fill(bodyMiddle, upTrend, color.new(color.green, 90), fillgaps=false)
fill(bodyMiddle, downTrend, color.new(color.red, 90), fillgaps=false)

///////////////////////////////////////////////////
////////////////////Strategy///////////////////////
///////////////////////////////////////////////////

var bool longCond                    = na, var bool shortCond                   = na, longCond := nz(longCond[1]), shortCond := nz(shortCond[1])
var int CondIni_long                 = 0, var int CondIni_short                 = 0, CondIni_long := nz(CondIni_long[1]), CondIni_short := nz(CondIni_short[1])
var float open_longCondition         = na, var float open_shortCondition   = na


long  = ta.change(direction) < 0
short = ta.change(direction) > 0


longCond        :=                                                              long
shortCond       :=                                                              short

CondIni_long    :=                                                              longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_long[1])
CondIni_short   :=                                                              longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_short[1])
longCondition   =                                                               (longCond[1] and nz(CondIni_long[1]) == -1)
shortCondition  =                                                               (shortCond[1] and nz(CondIni_short[1]) == 1)


open_longCondition             :=                                          long ? close[1] :                                                      nz(open_longCondition[1])
open_shortCondition            :=                                          short ? close[1] :                                                     nz(open_shortCondition[1])


//TP
tp                    = input.float(1.1  , "TP [%]",                      step = 0.1) 

//BACKTESTING inputs --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

testStartYear       =                   input.int(2000,                             title="start year",                                         minval = 1997, maxval = 3000,                                                   group= "BACKTEST") 
testStartMonth      =                   input.int(01,                               title="start month",                                        minval = 1, maxval = 12,                                                        group= "BACKTEST")
testStartDay        =                   input.int(01,                               title="start day",                                          minval = 1, maxval = 31,                                                        group= "BACKTEST")
testPeriodStart     =                   timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear        =                   input.int(3333,                             title="stop year",                                          minval=1980, maxval = 3333,                                                     group= "BACKTEST")
testStopMonth       =                   input.int(12,                               title="stop month",                                         minval=1, maxval=12,                                                            group= "BACKTEST")
testStopDay         =                   input.int(31,                               title="stop day",                                           minval=1, maxval=31,                                                            group= "BACKTEST")
testPeriodStop      =                   timestamp(testStopYear, testStopMonth, testStopDay, 0, 0)
testPeriod          =                   time >= testPeriodStart and time <= testPeriodStop ? true : false

// Backtest  ==================================================================================================================================================================================================================================================================================================================================


if longCond
    strategy.entry("L", strategy.long, when=testPeriod)

if shortCond
    strategy.entry("S", strategy.short, when=testPeriod)
    

strategy.exit("TP_L", "L", profit =((open_longCondition   *       (1+(tp/100))) - open_longCondition)/syminfo.mintick)

strategy.exit("TP_S", "S", profit =((open_shortCondition  *       (1+(tp/100))) - open_shortCondition)/syminfo.mintick)





Más.