Stratégie de trading à court terme basée sur la cassure et la régression des prix
ChaoZhang
Aperçu
Cette stratégie est basée sur une combinaison de rupture de prix et de régression de la ligne moyenne, et utilise plusieurs indicateurs pour la confirmation et le filtrage, permettant de juger et de suivre la tendance. La stratégie est adaptée aux transactions de courte et moyenne ligne, et bloque les petits bénéfices grâce à un mécanisme strict d’entrée et de sortie.
Principe de stratégie
Utilisez la moyenne HMA comme référence pour déterminer la direction de la tendance des prix. Les prix supérieurs à la moyenne sont en hausse et les prix inférieurs à la moyenne sont en baisse.
Le canal SSL sert d’indicateur de confirmation de la tendance par la direction du canal et la relation avec le prix.
Le TDFI est un indicateur quantitatif de la capacité de jugement. L’admission est accordée uniquement si la capacité atteint un certain niveau.
L’indicateur RVI sert d’indicateur d’exit, lorsque la forme de la ligne RVI change, juge la fin de la tendance et quitte la position.
L’indicateur ATR calcule le stop loss et le stop loss.
Conditions d’entrée: prix dépassant la ligne de référence, direction de la passerelle SSL conforme au prix, TDFI atteignant le seuil.
Conditions de sortie: modification de la forme de la ligne de référence RVI, ou reprise de la rupture de la ligne de référence et du canal SSL.
Analyse des avantages
Le filtrage des fausses percées peut être effectué efficacement à l’aide d’une combinaison de plusieurs indicateurs.
Les conditions d’entrée et de sortie sont très strictes, mais il est possible de contrôler une seule sortie.
Les prix des produits alimentaires sont plus élevés que les prix des produits alimentaires, et les prix des produits alimentaires sont plus élevés que ceux des produits alimentaires.
Les paramètres de l’indicateur ont une grande marge d’optimisation et peuvent être ajustés pour différents produits et cycles.
Analyse des risques
Il est impossible d’évaluer si la tendance va s’inverser, et il est possible que les excès de poids continuent de faire des hausses/baisses.
Les opérations à court terme présentent le risque d’une survente.
Le réglage des positions de stop est subjectif et peut être trop relâché ou trop serré.
Une mauvaise configuration des paramètres peut entraîner des transactions fréquentes ou insuffisantes.
Direction d’optimisation
Augmenter les indicateurs de jugement de tendance pour assurer l’exactitude de la direction de la tendance.
Ajout d’un indicateur de signal de retour pour réduire la probabilité d’une surcharge de poids.
Envisagez d’ajuster la dynamique de l’ATR à celle de l’ATR Trailing Stop, afin de rendre le stop loss plus dynamique.
Testez différents systèmes homogènes pour trouver la direction d’optimisation des paramètres.
Optimiser les paramètres de l’indicateur et les adapter aux variétés de transactions spécifiques.
Résumer
Cette stratégie permet d’affiner les signaux de trading grâce à la confirmation de plusieurs indicateurs. Un mécanisme de stop-loss strict contrôle les pertes individuelles. La stratégie convient aux personnes familiarisées avec les opérations d’analyse technique et peut être adaptée aux différentes cycles du marché grâce à un ajustement des paramètres.
/*backtest
start: 2022-11-06 00:00:00
end: 2023-11-12 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Designed per No Nonsense Forex VP rules
//Made to be as modular as possible, so we can swap the indicators in and out.
//Originated from causecelebre
//Tried to put in as much VP rules as possible
///////////////////////////////////////////////////
//Rules Implemented:
///////////////////////////////////////////////////
// - SL 1.5 x ATR
// - TP 1 x ATR
//
// - Entry conditions
//// - Entry within 1 candles of baseline + 1 x confirmation + volume
//// - Entry only if baseline is < 1 x ATR
// - Exit conditions
//// - Exit on exit indicator or when baseline or confirmation flip
///////////////////////////////////////////////////
//Trades entries
///////////////////////////////////////////////////
// - First entry L1 or S1 with standard SL and TP
// - Second entry L2 or S2 with standard SL and exit upon the exit conditions
///////////////////////////////////////////////////
//Included Indicators and settings
///////////////////////////////////////////////////
// - Baseline = HMA 20
// - Confirmtion = SSL 10
// - Volume = TDFI 4
// - Exit = RVI 4
///////////////////////////////////////////////////
//Credits
// Strategy causecelebre https://www.tradingview.com/u/causecelebre/
// TDFI causecelebre https://www.tradingview.com/u/causecelebre/
// SSL Channel ErwinBeckers https://www.tradingview.com/u/ErwinBeckers/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
strategy(title="NNFX Strategy | jh", overlay = true )
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Set the main stuff ****
///////////////////////////////////////////////////
//Price
price = close
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ATR stuff
///////////////////////////////////////////////////
atrLength = input(14, "ATR Length")
slMultiplier = input(1.5, "SL")
tpMultiplier = input(1, "TP")
atr = atr(atrLength)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Baseline ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//HMA 20
///////////////////////////////////////////////////
hmaslowlength = input(20, minval=1)
src = input(close, title="Source")
slowhullma = wma(2*wma(src, hmaslowlength/2)-wma(src, hmaslowlength), round(sqrt(hmaslowlength)))
plot(slowhullma, title = "baseline", color = yellow, linewidth=2, transp=0)
///////////////////////////////////////////////////
// Base Signals
///////////////////////////////////////////////////
///////////////////////////////////////////////////
baseline = slowhullma
//Signals based on crossover
//baseShort = crossover(baseLine, price)
//baseLong = crossover(price, baseLine)
//Signals based on signal position
b_Short = baseline > price ? 1 : 0
l_Long = baseline < price ? 1 : 0
baseShort = b_Short
baseLong = l_Long
///////////////////////////////////////////////////
//ATR Check
///////////////////////////////////////////////////
distBasefromPrice = abs(baseline - price)
atrCheck = distBasefromPrice <= atr ? 1 : 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Confirmation ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//SSL Channel
///////////////////////////////////////////////////
sslLen=input(title="SSL Period", defval=10)
smaHigh=sma(high, sslLen)
smaLow=sma(low, sslLen)
Hlv = na
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh: smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////////////////////////////////////////////
//Confirm Signals
///////////////////////////////////////////////////
c_Up = sslUp
c_Down = sslDown
//Signals based on crossover
c_Long = crossover(c_Up, c_Down)
c_Short = crossover(c_Down, c_Up)
confirmLong = c_Long
confirmShort = c_Short
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Volume Indicator Start ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//TDFI
///////////////////////////////////////////////////
lookback = input(4, title = "TDFI Lookback")
filterHigh = input(0.05, title = "Filter High")
filterLow = input(-0.05, title = "Filter Low")
mma = ema(price * 1000, lookback)
smma = ema(mma, lookback)
impetmma = mma - mma[1]
impetsmma= smma - smma[1]
divma = abs(mma - smma)
averimpet = (impetmma + impetsmma) / 2
number = averimpet
pow = 3
result = na
for i = 1 to pow - 1
if i == 1
result := number
result := result * number
tdf = divma * result
ntdf = tdf / highest(abs(tdf), lookback * 3)
///////////////////////////////////////////////////
//Volume Signals
///////////////////////////////////////////////////
v_Long = ntdf > filterHigh ? 1 : 0
v_Short = filterLow > ntdf ? 1 : 0
volumeLong = v_Long
volumeShort = v_Short
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Exit Indicator ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//RVI 4
///////////////////////////////////////////////////
rgvlen = input(4, title="RVI Length", minval=1)
rvi = sum(swma(close-open), rgvlen)/sum(swma(high-low),rgvlen)
sig = swma(rvi)
///////////////////////////////////////////////////
//Exit Signals
///////////////////////////////////////////////////
e_Short = crossover(rvi, sig)
e_Long = crossover(sig, rvi)
exitOutofShort = e_Short
exitOutofLong = e_Long
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **************************** Logic to handle NNFX rules ****************************
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Checking for base and confirmation indication with 1 candle difference
baseandConfirmLong = ((baseLong[0] and confirmLong[0]) or (baseLong[1] and confirmLong[0]) or (baseLong[1] and confirmLong[1]) or (baseLong[0] and confirmLong[1])) ? 1 : 0
baseandConfirmShort = ((baseShort[0] and confirmShort[0]) or (baseShort[1] and confirmShort[0]) or (baseShort[1] and confirmShort[1]) or (baseShort[0] and confirmShort[1])) ? 1 : 0
//Combining with volume with 1 candle difference
enterLong = ((baseandConfirmLong[0] and volumeLong[0]) or (baseandConfirmLong[1] and volumeLong[0]) or (baseandConfirmLong[1] and volumeLong[1]) or (baseandConfirmLong[0] and volumeLong[1])) ? 1 : 0
enterShort = ((baseandConfirmShort[0] and volumeShort[0]) or (baseandConfirmShort[1] and volumeShort[0]) or (baseandConfirmShort[1] and volumeShort[1]) or (baseandConfirmShort[0] and volumeShort[1])) ? 1 : 0
//Exit on base or confirmation flip over
baseandConfirmFliptoShort = ((baseShort[0] or confirmShort[0]) or (baseShort[1] or confirmShort[0]) or (baseShort[1] or confirmShort[1]) or (baseShort[0] or confirmShort[1])) ? 1 : 0
baseandConfirmFliptoLong = ((baseLong[0] or confirmLong[0]) or (baseLong[1] or confirmLong[0]) or (baseLong[1] or confirmLong[1]) or (baseLong[0] or confirmLong[1])) ? 1 : 0
//Exit on base and confirmation flip or exit indicator
exitLong = exitOutofLong or baseandConfirmFliptoShort ? 1 : 0
exitShort = exitOutofShort or baseandConfirmFliptoLong ? 1 : 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Entries and Exits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (year>2009)
//Long entries with standard 1.5 ATR for SL, 1 ATR for TP
long_sl = price - atr * slMultiplier
long_tp = price + atr * tpMultiplier
strategy.entry("L1", strategy.long, when = enterLong and atrCheck)
strategy.exit("L1 SL Exit", "L1", stop = long_sl, limit = long_tp)
strategy.close("L1", when = exitLong)
//Long entries with no TP
strategy.entry("L2", strategy.long, when = enterLong and atrCheck)
strategy.exit("L2 SL Exit", "L2", stop = long_sl)
strategy.close("L2", when = exitLong)
//Short entries with standard 1.5 ATR for SL, 1 ATR for TP
short_sl = price + atr * slMultiplier
short_tp = price - atr * tpMultiplier
strategy.entry("S1", strategy.short, when = enterShort and atrCheck)
strategy.exit("S1 SL Exit", "Short1", stop = short_sl, limit = short_tp)
strategy.close("S1", when = exitShort)
//Short entries with no TP
strategy.entry("S2", strategy.short, when = enterShort and atrCheck)
strategy.exit("S2 Exit", stop = short_sl)
strategy.close("S2", when = exitShort)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//End
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////