Stratégie d'inversion du retracement de Hulk
ChaoZhang
Aperçu
La stratégie de retrait est une stratégie qui utilise des indicateurs tels que la moyenne, le MACD, le RSI et l’ADX pour capturer le renversement de tendance et effectuer une entrée dans la phase de retrait. Elle est spécialement conçue pour le roi de la radicalisation, en utilisant ses caractéristiques de retrait courantes pour effectuer des opérations de renversement.
Principe de stratégie
La stratégie utilise l’EMA pour déterminer la direction de la tendance globale et pour construire les zones de faiblesse de la tendance. Lorsque le prix revient de la zone de force à la zone de faiblesse, la stratégie détermine que la tendance présente une opportunité de revirement.
Afin de filtrer les erreurs, la stratégie inclut l’indicateur MACD pour juger des signaux de reprise à court terme. La valeur absolue du MACD est supérieure à une certaine amplitude, ce qui augmente les chances de reprise. Dans le même temps, la valeur ADX est requise au-dessus d’un certain niveau, ce qui garantit que le marché actuel est en tendance et non sur le marché de la liquidation.
Enfin, l’indicateur RSI sert à éviter les zones de survente et les zones de survente. Un signal est émis lorsque le RSI est limité à une certaine plage.
Chaque fois que l’EMA est croisée, le nombre de transactions stratégiques est égal à zéro. Il est également possible de définir le nombre maximal de transactions à chaque croisement, afin d’éviter les transactions répétitives.
Lorsque les conditions sont remplies, un ordre de commande est défini en fonction du ratio stop loss/stopstop et un trade inverse est effectué.
Analyse des avantages
Le plus grand avantage de cette stratégie est d’utiliser les zones de force et de faiblesse construites par l’EMA pour capturer les caractéristiques de retrait du roi de l’acier radical. L’utilisation de plusieurs indicateurs de filtrage de l’intrusion erronée est plus fiable.
Cette stratégie, combinée à un jugement de tendance par rapport à un seul indicateur de choc, permet de réduire les inversions inutiles. En même temps, le contrôle du nombre maximal de transactions à chaque croisement d’EMA permet d’éviter une augmentation des pertes en cas de transactions répétées.
Analyse des risques
Le plus grand risque de cette stratégie réside dans le fait que le roi ne soit pas retiré. Si le roi brise directement l’EMA pour continuer à monter ou à descendre, la stratégie génère un faux signal et s’inverse. Un arrêt est nécessaire pour contrôler les pertes.
En outre, des paramètres d’indicateur déraisonnables peuvent également entraîner une baisse de la qualité du signal. Les paramètres d’optimisation doivent être testés à plusieurs reprises pour s’adapter aux différentes conditions du marché.
Enfin, le fait de fixer un stop-loss trop élevé, ou de continuer à faire des secousses radicales après un renversement, peut augmenter les pertes individuelles. Cela nécessite un stop-loss raisonnable et une meilleure gestion des risques.
Direction d’optimisation
Cette stratégie peut être optimisée dans les domaines suivants:
Les tests de différents marchés et paramètres permettent à l’EMA de mieux cerner les tendances;
Optimisation des paramètres MACD pour une meilleure précision et fiabilité des signaux de retournement;
Il est possible d’ajuster la gamme de paramètres du RSI pour éviter des zones de survente trop radicales.
Optimiser le ratio de stop-loss et de stop-loss pour réduire le risque de perte unique.
Résumer
La stratégie de retour en arrière du roi des tours est spécialement conçue pour effectuer un retour en arrière sur les caractéristiques de retour du roi des tours, ce qui permet de saisir efficacement les opportunités de retour à court terme. Elle utilise plusieurs filtres EMA pour déterminer la direction et la force de la tendance; et confirme l’entrée en bourse avec des indicateurs tels que MACD, RSI, etc. La fiabilité est élevée.
/*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)