Une stratégie de trading de tortues qui suit la dynamique de rupture


Date de création: 2023-12-25 17:12:05 Dernière modification: 2023-12-25 17:12:05
Copier: 0 Nombre de clics: 774
1
Suivre
1623
Abonnés

Une stratégie de trading de tortues qui suit la dynamique de rupture

Aperçu

La stratégie de trading Turtle est une stratégie de suivi des tendances qui suit la dynamique des ruptures. Elle a été développée par le célèbre trader Richard Dennis dans les années 1980 pour vérifier si les traders peuvent être formés par des règles plutôt que par des règles innées. Le concept central de la stratégie est de suivre les ruptures de prix et de suivre la tendance, tout en respectant strictement les principes de gestion de fonds pour limiter les risques de baisse.

Principe de stratégie

La stratégie de négociation de l’orage utilise deux paramètres N et N / 2 pour construire des canaux. Plus précisément, le prix le plus élevé et le prix le plus bas des derniers N jours et N / 2 jours sont calculés respectivement.

Dans le code, N correspondenter_slowN/2 correspondant àenter_fastLes prix les plus élevés des 55 derniers jours et des 20 derniers jours sont calculés respectivement.slowLetfastLLe prix le plus baslowest(slowSfastS)。当价格超过55天通道时做多(enterL2),当价格跌破20天通道时平多仓(exitL1);当价格跌破55天通道时做空(enterS2),当价格超过20天通道时平空仓(exitS1`)。

Analyse des avantages

Le plus grand avantage de la stratégie de négociation de la tortue réside dans la maîtrise du risque. En établissant une position lors d’une rupture de prix et en arrêtant rapidement les pertes lors d’une reprise de prix, il est possible de contrôler efficacement les pertes individuelles.

Un autre avantage est la simplicité de sélection des paramètres. La stratégie entière ne comporte que 4 paramètres, ce qui est facile à comprendre et à ajuster. Les paramètres eux-mêmes sont également relativement stables et ne nécessitent pas d’optimisation fréquente.

Analyse des risques

Le risque le plus important de la stratégie de négociation de la côte est l’incapacité de suivre la tendance à long terme. Lorsque la tendance commence à se former, la stratégie peut manquer une opportunité d’entrée. De plus, la stratégie ouvre fréquemment des positions blanches dans une tendance à la volatilité des prix, augmentant les coûts de négociation et le risque de points de glissement.

En outre, les paramètres fixes peuvent varier considérablement selon les variétés et les environnements de marché. Cela nécessite une adaptation de l’expérience manuelle.

Direction d’optimisation

Les stratégies de négociation de la morue peuvent être optimisées dans les domaines suivants:

  1. Ajout de la fonction d’adaptation des paramètres. Permet d’ajuster automatiquement les paramètres N, N/2 en fonction de la volatilité du marché et de la fréquence du signal, pour s’adapter à plus de scénarios.

  2. Ajout d’une règle de jugement de la tendance. Déterminer la direction de la tendance avant l’entrée, éviter l’entrée erronée dans une situation de fluctuation des prix.

  3. Combiner plusieurs stratégies d’unité de périodes de temps. Déterminer la direction de la tendance dans les périodes de temps plus élevées et entrer dans les périodes de temps plus faibles.

  4. Optimiser les stratégies de stop loss. Trailing Stop Loss ou Stop Loss de Temps, réduire les retraits.

Résumer

La stratégie de négociation de la tortue permet un suivi efficace des tendances grâce à un système de rupture simple. La maîtrise du risque est le plus grand avantage de la stratégie, grâce à la gestion rapide des pertes et des fonds fixes. Dans le même temps, nous voyons également que la stratégie peut être étendue et optimisée à plusieurs dimensions pour s’adapter à plus de variétés et d’environnements de marché.

Code source de la stratégie
/*backtest
start: 2022-12-24 00:00:00
end: 2023-12-24 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=2
//oringinally coded by tmr0, modified by timchep
//original idea from «Way of the Turtle: The Secret Methods that Turned Ordinary People into Legendary Traders» (2007) CURTIS FAITH
strategy("Turtles", shorttitle = "Turtles", overlay=true, pyramiding=1, default_qty_type= strategy.percent_of_equity, default_qty_value = 100)
//////////////////////////////////////////////////////////////////////
// Component Code Start
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(12, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

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)

// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=false)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
// Component Code Stop
//////////////////////////////////////////////////////////////////////

shortingEnabled = input(title="Enable Shorting?", type=bool, defval=true)

enter_fast = input(20, minval=1)
exit_fast = input(10, minval=1)
enter_slow = input(55, minval=1)
exit_slow = input(20, minval=1)

fastL = highest(enter_fast)
fastLC = lowest(exit_fast)
fastS = lowest(enter_fast)
fastSC = highest(exit_fast)

slowL = highest(enter_slow)
slowLC = lowest(exit_slow)
slowS = lowest(enter_slow)
slowSC = highest(exit_slow)

enterL1 = high > fastL[1] 
exitL1 = low <= fastLC[1] 
enterS1 = low < fastS[1]
exitS1 = high >= fastSC[1]

enterL2 = high > slowL[1] 
exitL2 = low <= slowLC[1] 
enterS2 = low < slowS[1]
exitS2 = high >= slowSC[1]


if testPeriod()
    strategy.entry("fast L", strategy.long, when = enterL1) 
    
    if not enterL1
        strategy.entry("slow L", strategy.long, when = enterL2)
        
    strategy.close("fast L", when = exitL1)
    strategy.close("slow L", when = exitL2)

if shortingEnabled and testPeriod()
    strategy.entry("fast S", strategy.short, when = enterS1)
    if not enterS2
        strategy.entry("slow S", strategy.short, when = enterS2)
        
    strategy.close("fast S", when = exitS1)
    strategy.close("slow S", when = exitS2)