Estrategia de reversión del retroceso de Hulk
ChaoZhang
Descripción general
La estrategia de retracción de los turnos de los reyes es una estrategia que utiliza indicadores como la línea media, el MACD, el RSI y el ADX para capturar una reversión de la tendencia y entrar en juego en la etapa de retracción. Se dirige específicamente a los reyes radicales y utiliza sus características comunes para realizar operaciones de reversión.
Principio de estrategia
La estrategia utiliza la EMA para determinar la dirección de la tendencia general y construir las zonas de tendencia fuerte y débil. La estrategia determina que hay oportunidades de reversión de la tendencia cuando el precio retrocede de la zona fuerte a la zona débil.
Para filtrar el error, la estrategia incluye el indicador MACD para juzgar la señal de reversión a corto plazo. Cuando el valor absoluto de MACD es mayor que un cierto margen, se considera que la oportunidad de reversión aumenta. Al mismo tiempo, se requiere que el valor de ADX sea superior a un cierto nivel, para asegurar que se encuentre actualmente en un mercado de tendencia y no en un mercado de liquidación.
Finalmente, el indicador RSI sirve para evitar compras en zonas de sobreventa y ventas en zonas de sobreventa. La señal se produce cuando el RSI se limita a un rango determinado.
Cada vez que la línea media de la EMA se cruza, el número de operaciones de la estrategia es cero. También se puede establecer el número máximo de operaciones por cruce, para evitar la repetición de las operaciones.
Cuando se cumplen las condiciones, se establece un mandato de acuerdo con la proporción de stop loss y stop-loss, y se realiza una operación de reversión.
Análisis de las ventajas
La mayor ventaja de esta estrategia es aprovechar las zonas de fuerza y debilidad construidas por la EMA para capturar las características de retroceso del rey de los ratones radicales. El uso de múltiples indicadores de filtración de errores es más fiable.
En comparación con un solo indicador de oscilación, la estrategia incluye un juicio de tendencia, lo que reduce las inversiones innecesarias. Al mismo tiempo, se controla el número máximo de transacciones que se cruzan en cada EMA para evitar grandes pérdidas en las transacciones repetidas.
Análisis de riesgos
El mayor riesgo de esta estrategia reside en que el rey de las monedas no retroceda. Si el rey de las monedas rompe directamente la EMA y continúa subiendo o bajando, la estrategia generará una señal errónea y entrará en reversión. En este momento se necesita un stop loss para controlar las pérdidas.
Además, los parámetros del indicador no son razonables y pueden causar una disminución de la calidad de la señal. Se requiere probar y optimizar los parámetros repetidamente para adaptarlos a las diferentes condiciones del mercado.
Finalmente, el establecimiento de un alto margen de pérdida o el seguimiento de un temblor radical después de la reversión pueden aumentar las pérdidas individuales. Esto requiere un alto margen razonable y una mayor gestión de riesgos.
Dirección de optimización
La estrategia puede ser optimizada en los siguientes aspectos:
La EMA también ha desarrollado un programa de análisis de tendencias para evaluar diferentes mercados y parámetros, con el fin de evaluar con mayor precisión las tendencias.
Optimización de los parámetros MACD para que la señal de inversión sea más precisa y fiable.
Ajustar el rango de los parámetros del RSI para evitar zonas de sobrecompra y sobreventa demasiado radicales;
Optimización de la proporción de stop loss para reducir el riesgo de pérdidas individuales.
Resumir
La estrategia de retorno y reversión del rey de los tirones se realiza específicamente para el retorno de las características del rey de los tirones radicales, lo que permite aprovechar eficazmente las oportunidades de reversión a corto plazo. Utiliza múltiples filtros de EMA para determinar la dirección y la fuerza de la tendencia; y confirma la entrada con indicadores como MACD, RSI, etc. La fiabilidad es alta.
/*backtest
start: 2023-09-16 00:00:00
end: 2023-10-16 00:00:00
period: 3h
basePeriod: 15m
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/
// © npietronuto1
//@version=5
strategy("Hulk Scalper x35 Leverage", shorttitle = "Smash Pullback Strat", overlay=true, initial_capital=100, default_qty_type=strategy.percent_of_equity, default_qty_value=100)
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//RSI
rsiLength = input.int(20)
RsiTopInput = input.int(2)
RsiBotInput = input.int(-2)
// toprsiLine = hline(RsiTopInput, title = "Rsi Top Line", linestyle = hline.style_solid)
// botrsiLine = hline(RsiBotInput, title = "Rsi Bottom Line", linestyle = hline.style_solid)
rsi = ta.rsi(close, rsiLength)
rsiWeighted = rsi - 50 //Zeros Rsi to look nicer
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
adxlen = input(14, title="ADX Smoothing")
dilen = input(14, title="DI Length")
dirmov(len) =>
up = ta.change(high)
down = -ta.change(low)
plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
truerange = ta.rma(ta.tr, len)
plus = fixnan(100 * ta.rma(plusDM, len) / truerange)
minus = fixnan(100 * ta.rma(minusDM, len) / truerange)
[plus, minus]
adx(dilen, adxlen) =>
[plus, minus] = dirmov(dilen)
sum = plus + minus
adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen)
sig = adx(dilen, adxlen)
ADXfilterlevel = input.int(33, title = "ADX filter amount")
// plot(sig, color=color.red, title="ADX")
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//MACD
FastMacdLength = input.int(12, group = "MACD")
SlowMacdLength = input.int(26, group = "MACD")
SignalLength = input.int(11, group = "MACD")
MacdTickAmountNeeded = input.float(5.45, title = "Tick Amount for entry", group = "MACD")
res = input.timeframe("1", group = "MACD")
// bullishgrow_col = input.color(defval = #3179f5)
// bullishweaken_col = input.color(defval = #00e1ff)
// bearishweaken_col = input.color(defval = #ff01f1)
// bearishgrow_col = input.color(defval = #9d00e5)
[FastMacd, SlowMacd, Macdhist] = ta.macd(close, FastMacdLength, SlowMacdLength, SignalLength)
//Pull MACD from Lower timeframe
MACD = request.security(syminfo.tickerid, res, Macdhist, gaps = barmerge.gaps_on)
//Grow and Fall Color
// getgrow_fall_col(Value) =>
// if Value >= 0
// if Value >= Value[1]
// color.new(bullishgrow_col, transp = 10)
// else if Value <= Value[1]
// color.new(bullishweaken_col, transp = 10)
// else if Value <= 0
// if Value <= Value[1]
// color.new(bearishgrow_col, transp = 10)
// else if Value >= Value[1]
// color.new(bearishweaken_col, transp = 10)
//CONDITIONS that check if MACD is overbought or oversold
MACDisAboveBand = MACD > MacdTickAmountNeeded
MACDisBelowBand = MACD < MacdTickAmountNeeded*-1
//Plot
// plot(MACD, style = plot.style_columns, color = getgrow_fall_col(MACD))
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//EMAs
//Inputs
EmaFastLength = input.int(50, title = "Ema Fast Length")
EmaSlowLength = input.int(200, title = "Ema Slow Length")
StrongUpTrendCol = input.color(color.rgb(74, 255, 163))
//WeakUptrend = input.color(color.rgb(74, 255, 163, 50))
StrongDownTrendCol = input.color(color.rgb(255, 71, 84))
//WeakDownTrend = input.color(color.rgb(255, 71, 84, 50))
//Calculations
emaFast= ta.ema(close, EmaFastLength)
emaSlow= ta.ema(close, EmaSlowLength)
emaDist=emaFast-emaSlow
EmaLengthFraction = emaDist/4
emafrac5 = emaSlow + EmaLengthFraction
emafrac4 = emaSlow + EmaLengthFraction*2
emafrac3 = emaSlow + EmaLengthFraction*3
emafrac2 = emaSlow + EmaLengthFraction*4
UptrendCol_DowntrendCol= emaFast>=emaSlow ? StrongUpTrendCol:StrongDownTrendCol
//Plot
ema1p = plot(emaFast, color = color.new(#000000, transp = 100))
ema2p = plot(emafrac2, color = color.new(#000000, transp = 100))
ema3p = plot(emafrac3, color = color.new(#000000, transp = 100))
ema4p = plot(emafrac4, color = color.new(#000000, transp = 100))
ema5p = plot(emafrac5, color = color.new(#000000, transp = 100))
ema6p = plot(emaSlow, color = color.new(#000000, transp = 100))
fill(ema2p,ema3p, color = color.new(UptrendCol_DowntrendCol, 70))
fill(ema3p,ema4p, color = color.new(UptrendCol_DowntrendCol, 60))
fill(ema4p,ema5p, color = color.new(UptrendCol_DowntrendCol, 50))
fill(ema5p,ema6p, color = color.new(UptrendCol_DowntrendCol, 40))
//Conditons
FastEma_above_SlowEma = emaFast > emaSlow
FastEma_below_SlowEma = emaFast < emaSlow
emaCrossEvent = ta.crossover(emaFast, emaSlow) or ta.crossover(emaSlow, emaFast)
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Trade Cap per EMA X
//Inputs
MaxTrades_PerCross_Checkbox = input.bool(true, "Limit Trades Per Cross", group = "Filters")
TrdCount = 0//Variable that keeps current trade count
if(TrdCount[1] > 0)//Passes variable on to current candle
TrdCount := TrdCount[1]
//Reset trade count if EMAs X
emaXevent = ta.crossover(emaFast, emaSlow) or ta.crossover(emaSlow, emaFast) // Check for EMA cross
if(emaXevent)
TrdCount := 0
//Conditions
MaxTrades = input.int(6)
IsMaxTrades_BelowCap = TrdCount[1] < MaxTrades //Condition that applies max trade count
if(not MaxTrades_PerCross_Checkbox)
IsMaxTrades_BelowCap := true
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//STRATEGY LOGIC
//Parameters
TakeProfitInput = input.float(0.0135, title = "Take Profit %", group = "TP/SL")
StopLossInput = input.float(0.011, title = "Stop Loss %", group = "TP/SL")
//TP/SL calculations
Long_takeProfit = close * (1 + TakeProfitInput)
Long_stopLoss = close * (1 - StopLossInput)
Short_takeProfit = close * (1 - TakeProfitInput)
Short_stopLoss = close * (1 + StopLossInput)
//LONG and Short
LongConditionPt1 = close > emaSlow and MACDisBelowBand and sig > ADXfilterlevel
LongConditionPt2 = FastEma_above_SlowEma and IsMaxTrades_BelowCap and strategy.position_size == 0
//Checks if Rsi Inbetween Lines
LongConditionPt3 = rsiWeighted < RsiTopInput and rsiWeighted > RsiBotInput
ShortConditionPt1 = close < emaSlow and MACDisAboveBand and sig > ADXfilterlevel
ShortConditionPt2 = FastEma_below_SlowEma and IsMaxTrades_BelowCap and strategy.position_size == 0
//Checks if Rsi Inbetween Lines
ShortConditionPt3 = rsiWeighted < RsiTopInput and rsiWeighted > RsiBotInput
// longCondition = FastEma_above_SlowEma and MACDisBelowBand and IsMaxTrades_BelowCap and rsiWeighted < RsiTopInput and strategy.position_size == 0
longCondition = LongConditionPt1 and LongConditionPt2 and LongConditionPt3
if(longCondition)
strategy.entry("long", strategy.long)
strategy.exit("exit", "long", limit = Long_takeProfit, stop = Long_stopLoss)
TrdCount := TrdCount + 1//ADD to Max Trades Count
alert("Go Long with TP at" + str.tostring(Long_takeProfit) + "and SL at" + str.tostring(Long_stopLoss), alert.freq_once_per_bar_close)
shortCondition = ShortConditionPt1 and ShortConditionPt2 and ShortConditionPt3
if(shortCondition )
strategy.entry("short", strategy.short)
strategy.exit("exit", "short", limit = Short_takeProfit, stop = Short_stopLoss)
TrdCount := TrdCount + 1 //ADD to Max Trades Count
alert("Go Short with TP at" + str.tostring(Short_takeProfit) + "and SL at" + str.tostring(Short_stopLoss), alert.freq_once_per_bar_close)