Indicador de Botvenko adaptativo Estrategia corta larga

El autor:¿ Qué pasa?, Fecha: 2024-01-04 16:09:30
Las etiquetas:

Resumen general

Esta estrategia se desarrolla sobre la base del indicador Botvenko para identificar automáticamente las tendencias del mercado y establecer posiciones largas / cortas.

Principio de la estrategia

El indicador central de esta estrategia es el indicador Botvenko. Al calcular la diferencia logarítmica entre los precios de cierre en diferentes días de negociación, juzga la tendencia del mercado y los niveles de soporte / resistencia importantes.

Además, la estrategia integra un cinturón de protección EMA compuesto por promedios móviles de 21 días, 55 días y otros. Determina si el estado actual es un mercado alcista, mercado bajista o mercado de consolidación basado en la relación de clasificación de estos promedios móviles, y en consecuencia restringe las operaciones cortas o largas.

Al identificar las señales de negociación con el indicador Botvenko y juzgar las etapas del mercado con medias móviles, se puede evitar el establecimiento de posiciones inapropiadas cuando se utilizan en combinación.

Análisis de ventajas

La mayor ventaja de esta estrategia es que puede identificar automáticamente las tendencias largo / corto del mercado. El indicador Botvenko es muy sensible a la diferencia entre los precios en dos períodos de tiempo y puede localizar rápidamente los niveles clave de soporte / resistencia. Al mismo tiempo, la clasificación de los promedios móviles puede juzgar efectivamente si actualmente es mejor ser largo o corto.

Esta idea de combinar indicadores rápidos e indicadores de tendencia permite a la estrategia localizar rápidamente los puntos de entrada y salida, evitando al mismo tiempo compras y ventas inapropiadas.

Análisis de riesgos

Los riesgos de esta estrategia provienen principalmente de dos aspectos. Primero, el indicador Botvenko en sí es muy sensible a los cambios de precios, lo que puede generar muchas señales comerciales innecesarias. Segundo, la clasificación de los promedios móviles puede ser desordenada durante los movimientos laterales, lo que conduce al establecimiento de posiciones desordenadas.

Para abordar el primer riesgo, los parámetros del indicador Botvenko pueden ajustarse para aumentar el ciclo de cálculo y reducir las operaciones innecesarias.

Direcciones de optimización

Las principales direcciones de optimización son el ajuste de parámetros y la adición de condiciones de filtro.

Para el indicador Botvenko, se pueden probar diferentes parámetros de período para encontrar la combinación óptima. Para las medias móviles, se pueden agregar más de ellos para formar un sistema de juicio de tendencia más completo. Además, también se pueden introducir indicadores de volatilidad, indicadores de volumen de negociación, etc. para filtrar señales falsas.

A través de ajustes integrales de los parámetros y las condiciones de filtro, la estabilidad y la rentabilidad de la estrategia pueden mejorarse aún más.

Resumen de las actividades

La estrategia adaptativa Botvenko larga / corta combina con éxito indicadores rápidos y de tendencia para identificar automáticamente los puntos clave del mercado y establecer posiciones correctas. Sus ventajas se encuentran en la ubicación rápida y la prevención de posiciones inapropiadas.

/*backtest
start: 2023-12-27 00:00:00
end: 2024-01-03 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © boftei

//@version=5

strategy("Boftei's Strategy", overlay=false, pyramiding=1, default_qty_type= strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills=false, margin_long = 100, margin_short = 100, slippage=0, commission_type=strategy.commission.percent, commission_value = 0, initial_capital = 40, precision = 6)
strat_dir_input = input.string("all", "strategy direction", options=["long", "short", "all"])
strat_dir_value = strat_dir_input == "long" ? strategy.direction.long : strat_dir_input == "short" ? strategy.direction.short : strategy.direction.all
strategy.risk.allow_entry_in(strat_dir_value)
//////////////////////////////////////////////////////////////////////
//DATA
testStartYear = input(2005, "Backtest Start Year")
testStartMonth = input(7, "Backtest Start Month")
testStartDay = input(16, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
//Stop date if you want to use a specific range of dates
testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)


testPeriod() =>
    time >= testPeriodStart and time <= testPeriodStop ? true : false
//////////////////////////////////////////////////////////////////////
sell = input.float(0.0065, "sell level")
buy = input.float(0, "buy level")
long1 = input.float(-0.493, "long retry - too low")
long2 = input.float(2, "long close up")
long3 = input.float(-1.5, "long close down")
short1 = input.float(1.26, "short retry - too high")
short2 = input.float(-5, "dead - close the short")
///< botvenko script
nn = input(60, "Histogram Period")
float x = 0
float z = 0
float k = 0



y = math.log(close[0]) - math.log(close[nn])
if y>0
    x := y
else
    k := y
//---------------------------------------------
        
plot(y > 0 ? x: 0, color = color.green, linewidth = 4)
plot(y <= 0 ? k: 0, color = color.maroon, linewidth = 4)
plot(y, color = color.yellow, linewidth = 1)

co = ta.crossover(y, buy)
cu = ta.crossunder(y, sell)
retry_long = ta.crossunder(y, long1)
deadline_long_up = ta.crossover(y, long2)
deadline_long_down = ta.crossunder(y, long3)
retry_short = ta.crossover(y, short1)
deadline_short = ta.crossunder(y, short2)


hline(buy, title='buy', color=color.green, linestyle=hline.style_dotted, linewidth=2)
hline(0, title='zero', color=color.white, linestyle=hline.style_dotted, linewidth=1)
hline(sell, title='sell', color=color.red, linestyle=hline.style_dotted, linewidth=2)
hline(long1, title='long retry', color=color.blue, linestyle=hline.style_dotted, linewidth=2)
hline(long2, title='overbought', color=color.teal, linestyle=hline.style_dotted, linewidth=2)
hline(long3, title='oversold', color=color.maroon, linestyle=hline.style_dotted, linewidth=2)
hline(short1, title='short retry', color=color.purple, linestyle=hline.style_dotted, linewidth=2)
hline(short2, title='too low to short - an asset may die', color=color.navy, linestyle=hline.style_dotted, linewidth=2)


////////////////////////////////////////////////////////////EMAprotectionBLOCK
ema_21 = ta.ema(close, 21)
ema_55 = ta.ema(close, 55)
ema_89 = ta.ema(close, 89)
ema_144 = ta.ema(close, 144)
//ema_233 = ta.ema(close, 233)
// ema_377 = ta.ema(close, 377)

long_st = ema_21>ema_55 and ema_55>ema_89 and ema_89>ema_144 //and ema_144>ema_233 and ema_233>ema_377
short_st = ema_21<ema_55 and ema_55<ema_89 and ema_89<ema_144 //and ema_144<ema_233 and ema_233<ema_377 

g_v = long_st == true?3:0
r_v = short_st == true?-2:0
y_v = long_st != true and short_st != true?2:0

plot(math.log(ema_21), color = color.new(#ffaf5e, 50))
plot(math.log(ema_55), color = color.new(#b9ff5e, 50))
plot(math.log(ema_89), color = color.new(#5eff81, 50))
plot(math.log(ema_144), color = color.new(#5effe4, 50))
//plot(math.log(ema_233), color = color.new(#5e9fff, 50))
//plot(math.log(ema_377), color = color.new(#af5eff, 50))

plot(long_st == true?3:0, color = color.new(color.green, 65), linewidth = 5)
plot(short_st == true?-2:0, color = color.new(color.red, 65), linewidth = 5)
plot(long_st != true and short_st != true?2:0, color = color.new(color.yellow, 65), linewidth = 5)
////////////////////////////////////////////////////////////EMAprotectionBLOCK




if (co and testPeriod() and (g_v == 3 or y_v == 2))
    strategy.close("OH BRO", comment = "EXIT-SHORT")
    strategy.close("OH DUDE", comment = "EXIT-SHORT")
	strategy.entry("OH DAMN", strategy.long, comment="ENTER-LONG 'co'")
if (retry_long and testPeriod() and (g_v == 3 or y_v == 2))
    strategy.close("OH DAMN", comment = "EXIT-LONG")
    strategy.entry("OH BRUH", strategy.long, comment="ENTER-LONG 'retry_long'")
	
if (cu and testPeriod() and (r_v == -2 or y_v == 2))
    strategy.close("OH DAMN", comment = "EXIT-LONG")
    strategy.close("OH BRUH", comment = "EXIT-LONG")
	strategy.entry("OH BRO", strategy.short, comment="ENTER-SHORT 'cu'")
if (retry_short and testPeriod() and (r_v == -2 or y_v == 2))
    strategy.close("OH BRO", comment = "EXIT-SHORT")
    strategy.entry("OH DUDE", strategy.short, comment="ENTER-SHORT 'retry_short'")
	
    
if (deadline_long_up and testPeriod() or r_v == -2 and testPeriod())
    strategy.close("OH DAMN", comment = "EXIT-LONG 'deadline_long_up'")
if (deadline_long_down and testPeriod())
    strategy.close("OH DAMN", comment = "EXIT-LONG 'deadline_long_down'")
if (deadline_short and testPeriod() or g_v == 3 and testPeriod())
    strategy.close("OH BRO", comment = "EXIT-SHORT 'deadline_short'")
    // (you can use strategy.close_all(comment = "close all entries") here)

Más.