Les ressources ont été chargées... Je charge...
  1. Carré
  2. La stratégie de rupture de l'élan

La stratégie de rupture de l'élan

Auteur:ChaoZhang est là., Date: 2024-02-23 14h27 et 21h
Les étiquettes:

img

Résumé

La stratégie de rupture de l'élan est une stratégie de suivi de tendance qui suit l'élan du marché. Elle combine plusieurs indicateurs pour juger si le marché est actuellement dans une tendance à la hausse ou à la baisse, et ouvre des positions longues en franchissant les niveaux de résistance clés et ouvre des positions courtes en franchissant les niveaux de support clés.

La logique de la stratégie

Cette stratégie utilise principalement des canaux de Donchian de plusieurs délais pour déterminer les tendances du marché et les niveaux de prix clés. Plus précisément, lorsque les prix franchissent le rail supérieur du canal de Donchian à plus long terme, comme 40 jours, il est jugé comme une tendance haussière.

La stratégie fournit deux options pour les positions de sortie: ligne d'invalidation fixe et stop-loss de suivi. La ligne d'invalidation fixe utilise le rail inférieur/supérieur d'un canal de Donchian plus court comme 20 jours. La ligne d'arrêt de perte de suivi calcule une ligne de stop-loss dynamique chaque jour en fonction des valeurs ATR. Les deux méthodes peuvent contrôler efficacement les risques.

Analyse des avantages

Cette stratégie combine le jugement de tendance et les opérations de rupture, qui peuvent capturer efficacement les opportunités directionnelles à court terme sur le marché. Par rapport à des indicateurs uniques, elle utilise plusieurs filtres qui peuvent filtrer certaines fausses ruptures et améliorer la qualité des signaux d'entrée.

Analyse des risques

Le principal risque de cette stratégie est que les prix puissent fluctuer violemment, déclenchant des arrêts de perte pour les positions de sortie. Si les prix s'inversent rapidement par la suite, des opportunités pourraient être manquées. En outre, l'utilisation de plusieurs filtres peut également filtrer certaines opportunités et réduire la fréquence des transactions.

Pour réduire les risques, les multiples ATR peuvent être ajustés ou les intervalles du canal de Donchian peuvent être élargis pour diminuer la probabilité d'un stop loss.

Directions d'optimisation

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

  1. Optimiser les longueurs des canaux de Donchian pour trouver la meilleure combinaison de paramètres.
  2. Essayez différents types de moyennes mobiles comme filtres.
  3. Ajustez le multiplicateur ATR ou utilisez des points fixes pour le stop loss.
  4. Ajoutez plus d'indicateurs de tendance comme le MACD.
  5. Optimiser les périodes de rétrospective pour les nouveaux sommets/baisses au cours de l'année, etc.

En testant différents paramètres, la combinaison optimale d'équilibrage des risques et des rendements peut être trouvée.

Conclusion

Cette stratégie combine plusieurs indicateurs pour déterminer la direction de la tendance et déclenche des transactions à des niveaux de rupture clés. Son mécanisme de stop loss le rend également résistant aux risques. En optimisant les paramètres, des rendements excessifs stables peuvent être obtenus.

/*backtest
start: 2024-01-23 00:00:00
end: 2024-02-22 00:00:00
period: 1h
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/
// © HeWhoMustNotBeNamed

//@version=4
strategy("BuyHigh-SellLow Strategy", overlay=true, initial_capital = 10000, default_qty_type = strategy.percent_of_equity, default_qty_value = 100, commission_type = strategy.commission.percent, pyramiding = 1, commission_value = 0.01, calc_on_order_fills = true)
donchianEntryLength = input(40, step=10)
donchianExitLength = input(20, step=10)

considerNewLongTermHighLows = input(true)
shortHighLowPeriod = input(120, step=10)
longHighLowPeriod = input(180, step=10)

considerMAAlignment = input(true)
MAType = input(title="Moving Average Type", defval="ema", options=["ema", "sma", "hma", "rma", "vwma", "wma"])
LookbackPeriod = input(40, minval=10,step=10)

atrLength = input(22)
atrMult = input(4)

exitStrategy = input(title="Exit Strategy", defval="tsl", options=["dc", "tsl"])

considerYearlyHighLow = input(true)
backtestYears = input(10, minval=1, step=1)
f_getMovingAverage(source, MAType, length)=>
    ma = sma(source, length)
    if(MAType == "ema")
        ma := ema(source,length)
    if(MAType == "hma")
        ma := hma(source,length)
    if(MAType == "rma")
        ma := rma(source,length)
    if(MAType == "vwma")
        ma := vwma(source,length)
    if(MAType == "wma")
        ma := wma(source,length)
    ma

f_getTrailingStop(atr, atrMult)=>
    stop = close - atrMult*atr
    stop := strategy.position_size > 0 ? max(stop, stop[1]) : stop
    stop

f_getMaAlignment(MAType, includePartiallyAligned)=>
    ma5 = f_getMovingAverage(close,MAType,5)
    ma10 = f_getMovingAverage(close,MAType,10)
    ma20 = f_getMovingAverage(close,MAType,20)
    ma30 = f_getMovingAverage(close,MAType,30)
    ma50 = f_getMovingAverage(close,MAType,50)
    ma100 = f_getMovingAverage(close,MAType,100)
    ma200 = f_getMovingAverage(close,MAType,200)

    upwardScore = 0
    upwardScore := close > ma5? upwardScore+1:upwardScore
    upwardScore := ma5 > ma10? upwardScore+1:upwardScore
    upwardScore := ma10 > ma20? upwardScore+1:upwardScore
    upwardScore := ma20 > ma30? upwardScore+1:upwardScore
    upwardScore := ma30 > ma50? upwardScore+1:upwardScore
    upwardScore := ma50 > ma100? upwardScore+1:upwardScore
    upwardScore := ma100 > ma200? upwardScore+1:upwardScore
    
    upwards = close > ma5 and ma5 > ma10 and ma10 > ma20 and ma20 > ma30 and ma30 > ma50 and ma50 > ma100 and ma100 > ma200
    downwards = close < ma5 and ma5 < ma10 and ma10 < ma20 and ma20 < ma30 and ma30 < ma50 and ma50 < ma100 and ma100 < ma200
    upwards?1:downwards?-1:includePartiallyAligned ? (upwardScore > 5? 0.5: upwardScore < 2?-0.5:upwardScore>3?0.25:-0.25) : 0

//////////////////////////////////// Calculate new high low condition //////////////////////////////////////////////////
f_calculateNewHighLows(shortHighLowPeriod, longHighLowPeriod, considerNewLongTermHighLows)=>
    newHigh = highest(shortHighLowPeriod) == highest(longHighLowPeriod) or not considerNewLongTermHighLows
    newLow = lowest(shortHighLowPeriod) == lowest(longHighLowPeriod) or not considerNewLongTermHighLows
    [newHigh,newLow]

//////////////////////////////////// Calculate Yearly High Low //////////////////////////////////////////////////
f_getYearlyHighLowCondition(considerYearlyHighLow)=>
    yhigh = security(syminfo.tickerid, '12M', high[1]) 
    ylow = security(syminfo.tickerid, '12M', low[1]) 
    yhighlast = yhigh[365]
    ylowlast = ylow[365]
    yhighllast = yhigh[2 * 365]
    ylowllast = ylow[2 * 365]
    
    yearlyTrendUp = na(yhigh)? true : na(yhighlast)? close > yhigh : na(yhighllast)? close > max(yhigh,yhighlast) : close > max(yhigh, min(yhighlast, yhighllast))
    yearlyHighCondition = (  (na(yhigh) or na(yhighlast) ? true : (yhigh > yhighlast) ) and ( na(yhigh) or na(yhighllast) ? true : (yhigh > yhighllast))) or yearlyTrendUp or not considerYearlyHighLow
    yearlyTrendDown = na(ylow)? true : na(ylowlast)? close < ylow : na(ylowllast)? close < min(ylow,ylowlast) : close < min(ylow, max(ylowlast, ylowllast))
    yearlyLowCondition = (  (na(ylow) or na(ylowlast) ? true : (ylow < ylowlast) ) and ( na(ylow) or na(ylowllast) ? true : (ylow < ylowllast))) or yearlyTrendDown or not considerYearlyHighLow
    
    label_x = time+(60*60*24*1000*1)
    [yearlyHighCondition,yearlyLowCondition]

donchian(rangeLength)=>
    upper = highest(rangeLength)
    lower = lowest(rangeLength)
    middle = (upper+lower)/2
    [middle, upper, lower]

inDateRange = true
[eMiddle, eUpper, eLower] = donchian(donchianEntryLength)
[exMiddle, exUpper, exLower] = donchian(donchianExitLength)
maAlignment = f_getMaAlignment(MAType, false)
[yearlyHighCondition, yearlyLowCondition] = f_getYearlyHighLowCondition(considerYearlyHighLow)
[newHigh,newLow] = f_calculateNewHighLows(shortHighLowPeriod, longHighLowPeriod, considerNewLongTermHighLows)

maAlignmentLongCondition = highest(maAlignment, LookbackPeriod) == 1 or not considerMAAlignment 

atr = atr(atrLength)
tsl = f_getTrailingStop(atr, atrMult)

//U = plot(eUpper, title="Up", color=color.green, linewidth=2, style=plot.style_linebr)
//D = plot(exLower, title="Ex Low", color=color.red, linewidth=2, style=plot.style_linebr)
longCondition = crossover(close, eUpper[1]) and yearlyHighCondition and newHigh and maAlignmentLongCondition
exitLongCondition = crossunder(close, exLower[1])

shortCondition = crossunder(close, eLower[1]) and yearlyLowCondition and newLow
exitShortCondition = crossover(close, exUpper[1])
strategy.entry("Buy", strategy.long, when=longCondition and inDateRange, oca_name="oca_buy")
strategy.exit("ExitBuyDC", "Buy", when=exitStrategy=='dc', stop=exLower)
strategy.exit("ExitBuyTSL", "Buy", when=exitStrategy=='tsl', stop=tsl)
plot(strategy.position_size > 0 ? (exitStrategy=='dc'?exLower:tsl) : na, title="Trailing Stop", color=color.red, linewidth=2, style=plot.style_linebr)
//strategy.close("Buy", when=exitLongCondition)
Plus de

2019 FMZ - Tous les droits réservés