Stratégie de percée de la double tortue

Auteur:ChaoZhang est là., Date: 2023-11-28 16:25:41 Je vous en prie.
Les étiquettes:

img

Résumé

La stratégie Double Turtle Breakthrough intègre la stratégie de rupture du trading de la tortue et le principe de stop loss en mouvement de Linda Raschke, avec une excellente performance de rupture et un contrôle strict des risques.

Principe de stratégie

La logique de base est d'aller court lors de la rupture du petit cycle haut sur le grand cycle haut point, et aller long lors de la rupture du petit cycle bas au grand cycle bas point. Après avoir ouvert une position, mettre en place un stop-loss en mouvement et prendre profit en mouvement, d'abord arrêter la perte pour confirmer le risque. Lorsque la quantité de détention s'accumule à l'ensemble de prendre profit quantité, annuler l'ordre de stop-loss dans le cycle suivant, puis sortir de la moitié de la position et mettre en place un stop-loss en mouvement et prendre profit en mouvement pour verrouiller les profits et suivre les spreads.

Les étapes spécifiques de l'opération sont les suivantes:

  1. Calculer le grand cycle (20 cycles) point élevé pré-High et le petit cycle (4 cycles) point élevé petitPériodeHigh.

  2. Lorsque le sommet de la dernière ligne K est supérieur à prevHigh et que prevHigh est supérieur à smallPeriodHigh, cela indique que le sommet du grand cycle dépasse le sommet du petit cycle.

  3. Après avoir ouvert une position, définissez un stop loss en mouvement. Attendez que la position s'inverse avant d'annuler l'ordre de stop loss pour éviter d'être arrêté.

  4. Lorsque la quantité de détention atteint le nombre de cycles de prise de profit en mouvement (actuellement 0 cycles), quittez la moitié de la position dans le cycle suivant et installez un stop loss en mouvement et une prise de profit en mouvement pour suivre l'écart et verrouiller les bénéfices.

  5. Pour les percées de basses positions, les positions longues sont établies sur la base des relations de percée entre les bas de cycle importants et les bas de cycle mineurs.

Analyse des avantages

Il s'agit d'une stratégie de percée très complète qui présente les avantages suivants:

  1. La combinaison de deux cycles de négociation des tortues peut permettre d'identifier efficacement les signaux de rupture.

  2. L'utilisation de techniques de stop loss et de prise de bénéfice en mouvement contrôle strictement les risques et évite d'énormes pertes.

  3. Sortir en deux étapes, en prenant la moitié des bénéfices à la fois, puis en sortant complètement en se déplaçant, en prenant des bénéfices, en bloquant les bénéfices.

  4. Prendre en compte à la fois les opérations longues et courtes, correspondant aux caractéristiques des marchés alternatifs multi-vide.

  5. Excellents résultats de backtesting avec de fortes performances commerciales réelles.

Analyse des risques

Les principaux risques et contre-mesures sont les suivants:

  1. Risque de fausses découvertes: ajuster les paramètres du cycle de manière appropriée pour assurer la validité des découvertes.

  2. Le risque de poursuite augmente et le risque de mort diminue.

  3. Risque d'élimination du stop loss: relâcher l'amplitude de stop loss de manière appropriée pour assurer un espace suffisant.

  4. Risque d'arrêt de perte trop sensible. Ajustez les réglages de glissement après l'arrêt de perte pour éviter les arrêts inutiles.

Directions d'optimisation

La stratégie peut également être optimisée dans les aspects suivants:

  1. Ajoutez des filtres de découverte de volume pour assurer l'authenticité des découvertes.

  2. Ajouter des indicateurs de jugement de tendance pour éviter d'ouvrir des positions à la fin des tendances.

  3. Combinez plus de cycles de temps pour déterminer le moment de la percée.

  4. Améliorer les algorithmes d'apprentissage automatique pour une optimisation dynamique des paramètres.

  5. Combiner avec d'autres stratégies d'arbitrage statistique.

Résumé

La stratégie Double Turtle Breakthrough utilise de manière complète des techniques de double cycle, des théories de rupture et des méthodes strictes de gestion des risques pour assurer des taux de gain élevés tout en assurant des rendements stables. Ce modèle de stratégie est simple et clair, facile à comprendre et à appliquer, et c'est une excellente stratégie quantitative. Cette stratégie a encore un grand potentiel d'optimisation. Les investisseurs peuvent innover sur cette base pour créer des systèmes de trading encore meilleurs.


/*backtest
start: 2022-11-21 00:00:00
end: 2023-11-27 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy(title = "Turtle soup plus one", shorttitle = "Turtle soup plus one", overlay=true)

bigPeriod = input(20)
smallPeriod = input(4)
takeProfitBars = input(0)
trailingStop = input(5, title = "Trailing stop percentages")
if (strategy.position_size == 0)
    strategy.cancel("Long")
    strategy.cancel("Short")
    strategy.cancel("Stop")



stopLossPrice = 0.1
stopLossPrice := nz(stopLossPrice[1])
takeProfitStarted = false
takeProfitStarted := nz(takeProfitStarted[1])

prevHigh = highest(high, bigPeriod - smallPeriod)[smallPeriod]
smallPeriodHigh = highest(high, smallPeriod - 1)[1]
if (high > prevHigh and prevHigh > smallPeriodHigh and close > prevHigh and strategy.position_size == 0)
    strategy.order("Short", strategy.short, stop = prevHigh)

if strategy.position_size < 0 and strategy.position_size[1] == 0
    stopLossPrice := high[1]
    strategy.order("Stop", strategy.long, qty = -strategy.position_size, stop = stopLossPrice)
    takeProfitStarted := false

if (strategy.position_size < 0 and sum(strategy.position_size, takeProfitBars) == strategy.position_size * takeProfitBars and close < strategy.position_avg_price and not takeProfitStarted)
    takeProfitStarted := true
    strategy.cancel("Stop")
    strategy.order("ExitHalf", strategy.long, qty = ceil(-strategy.position_size / 2), stop = close)
    if (strategy.position_size != -1)
        strategy.exit("ExitFull", "Short", qty = -strategy.position_size - ceil(-strategy.position_size / 2), loss = stopLossPrice, trail_price  = close, trail_offset = -(close - strategy.position_avg_price) * trailingStop / 100 / syminfo.mintick)
        

prevLow = lowest(low, bigPeriod - smallPeriod)[smallPeriod]
smallPeriodLow = lowest(low, smallPeriod - 1)[1]
if (low < prevLow and prevLow < smallPeriodLow and close < prevLow and strategy.position_size == 0)
    strategy.order("Long", strategy.long, stop = prevLow)

if strategy.position_size > 0 and strategy.position_size[1] == 0
    stopLossPrice := low[1]
    strategy.order("Stop", strategy.short, qty = strategy.position_size, stop = stopLossPrice)
    takeProfitStarted := false

if (strategy.position_size > 0 and sum(strategy.position_size, takeProfitBars) == strategy.position_size * takeProfitBars and close > strategy.position_avg_price and not takeProfitStarted)
    takeProfitStarted := true
    strategy.cancel("Stop")
    strategy.order("ExitHalf", strategy.short, qty = ceil(strategy.position_size / 2), stop = close)
    if (strategy.position_size != 1)
        strategy.exit("ExitFull", "Long", qty = strategy.position_size - ceil(strategy.position_size / 2),loss = stopLossPrice, trail_price  = close, trail_offset = (close - strategy.position_avg_price) * trailingStop / 100 / syminfo.mintick)

// === Backtesting Dates ===
testPeriodSwitch = input(false, "Custom Backtesting Dates")
testStartYear = input(2018, "Backtest Start Year")
testStartMonth = input(3, "Backtest Start Month")
testStartDay = input(6, "Backtest Start Day")
testStartHour = input(08, "Backtest Start Hour")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,testStartHour,0)
testStopYear = input(2038, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(14, "Backtest Stop Day")
testStopHour = input(14, "Backtest Stop Hour")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,testStopHour,0)
testPeriod() =>
    time >= testPeriodStart and time <= testPeriodStop ? true : false
isPeriod = testPeriodSwitch == true ? testPeriod() : true
// === /END
if not isPeriod
    strategy.cancel_all()
    strategy.close_all()

Plus de