
La stratégie de suivi de la tendance des marées dynamiques est une stratégie de suivi de la tendance basée sur les règles de négociation des marées. Elle utilise des indicateurs de marée pour identifier les tendances et, en combinaison avec des indicateurs de la dynamique, filtre une partie du bruit des transactions. Le principal avantage de cette stratégie est la possibilité de saisir des tendances de prix fortes et de réaliser des gains supplémentaires.
Cette stratégie utilise le système de rupture de base de l’indicateur du tsunami pour déterminer la direction de la tendance. Plus précisément, lorsque le prix de clôture est supérieur au plus haut des 20 derniers jours, c’est un signal positif.
Pour filtrer une partie du bruit des transactions, la stratégie a ajouté un facteur de dynamique. Si les fluctuations de prix sont inférieures à 5 ATR, la stratégie n’entre pas dans les transactions. Cela évite les pertes de transactions mineures causées par l’excès d’aérodynamisme.
Après avoir ouvert la position, la stratégie utilise la valeur N du principe de la pirogue pour franchir la sortie. Ce système établit un point de perte basé sur le prix le plus élevé et le prix le plus bas des 20 derniers jours. Par exemple, le prix de perte multiple est l’ATR de 2 N au-dessous du prix le plus bas des 20 derniers jours.
Le plus grand avantage de cette stratégie est qu’elle combine le suivi de la tendance et la gestion du volume. Le système de négociation de la tortue peut saisir avec précision la tendance des prix à moyen terme et éviter d’être dérangé par le bruit du marché. L’ajout du filtre de volume ATR peut réduire encore plus le nombre de transactions inutiles, ce qui augmente considérablement la marge de profit.
Plus précisément, cette stratégie présente les avantages suivants:
Bien qu’il y ait beaucoup de possibilités d’optimisation dans cette stratégie, elle comporte des risques potentiels à éviter:
D’après l’analyse des risques ci-dessus, la stratégie présente les principales améliorations suivantes:
La stratégie de suivi de la tendance des coulées dynamiques est une stratégie de suivi de la tendance des lignes moyennes et longues très pratique dans l’ensemble. Elle combine à la fois le filtrage des chocs de l’indicateur de jugement de tendance des coulées et de l’indicateur ATR, ce qui permet de bloquer efficacement les tendances de prix fortes. De plus, le contrôle des risques et l’optimisation des paramètres de la stratégie sont également très bien positionnés, ce qui peut réduire les retraits. L’efficacité de cette stratégie peut être encore améliorée si l’on continue à ajouter des modules tels que la gestion de position dynamique, le mécanisme de retournement et les objectifs de profit.
/*backtest
start: 2023-10-23 00:00:00
end: 2023-11-22 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Heiken Ashi BF 🚀", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2029, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
///////////// HA /////////////
haTicker = heikinashi(syminfo.tickerid)
haOpen = security(haTicker, "D", open)
haHigh = security(haTicker, "D", high)
haLow = security(haTicker, "D", low)
haClose = security(haTicker, "D", close)
///////////// Rate Of Change /////////////
source = close
roclength = input(30, minval=1)
pcntChange = input(7.0, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = haOpen < haClose and isMoving()
short = haOpen > haClose and isMoving()
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(2.0, title='Stop Loss %') / 100
tp_inp = input(5000.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
plotcandle(haOpen, haHigh, haLow, haClose, title='HA Candles', color = haOpen < haClose ? color.lime : color.red)
bgcolor(isMoving() ? long ? color.lime : short ? color.red : na : color.white, transp=70)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=50)