Les ressources ont été chargées... Je charge...

Stratégie de négociation basée sur le canal Donchain

Auteur:ChaoZhang est là., Date: 2024-02-27 14:57:37
Les étiquettes:

Résumé

Il s'agit d'une stratégie de trading qui utilise des canaux Donchain sur plusieurs délais pour déterminer les points d'entrée et de sortie.

La logique de la stratégie

La stratégie utilise principalement le concept des canaux Donchain, qui se compose des sommets, des fonds et des lignes intermédiaires des canaux.

Utilisez 52 périodes pour construire un canal Donchain à plus long terme et obtenir sa ligne supérieure, inférieure et moyenne.
Utilisez 12 périodes pour construire un canal Donchain à court terme et obtenir sa ligne supérieure, inférieure et moyenne.

Logique d'entrée: lorsque le prix dépasse le sommet du canal à plus long terme, nous le déterminons comme un signal d'entrée long.

Logique de sortie: lorsque le prix dépasse le bas du canal à court terme, nous le déterminons comme un signal de sortie pour fermer les positions longues. De même, nous avons besoin d'au moins 1 bougie dans les 3 dernières fermées en dessous de son bas du canal pour confirmer la validité de la ventilation.

Les avantages

La stratégie combine les avantages de la négociation de tendance suivie et de la négociation de réversion moyenne.
L'utilisation d'une analyse multi-temporelle permet de résoudre les problèmes liés aux fausses fuites et rend les entrées/sorties plus valides.
Les paramètres peuvent être optimisés pour différents produits et régimes de marché.

Risques et solutions

La stratégie est sensible aux paramètres. Différents paramètres peuvent conduire à des résultats radicalement différents. Des tests et une optimisation adéquats sont nécessaires pour trouver l'ensemble de paramètres optimal.
Un stop loss devrait être utilisé pour contrôler les pertes d'une seule transaction.
Il ne prend pas en compte le régime global du marché. Il peut échouer à des points d'inversion de tendance majeurs. D'autres indicateurs doivent être utilisés pour évaluer la tendance majeure.

Directions d'optimisation

Effectuer une optimisation des paramètres pour trouver les meilleurs paramètres, y compris les périodes de canal, les types de canal, etc.
Incorporer une logique de stop-loss avec des stops raisonnables pour contrôler les pertes.
Combiner d'autres indicateurs pour déterminer les tendances majeures, telles que l'EMA, les canaux Keltner, le MACD, etc., évitant ainsi les défaillances aux points de basculement clés.

Conclusion

En résumé, il s'agit d'une stratégie de rupture de canal Donchain typique à plusieurs délais. Elle intègre bien à la fois le suivi de tendance et la réversion moyenne pour capturer les renversements locaux au sein des tendances. Avec des paramètres optimisés, elle peut très bien fonctionner sur les marchés en tendance. Cependant, la stratégie elle-même est fragile, sensible aux paramètres et au régime global du marché. Il est recommandé de la combiner avec d'autres stratégies ou indicateurs pour obtenir des résultats plus robustes.

/*backtest
start: 2023-02-20 00:00:00
end: 2024-02-26 00:00:00
period: 1d
basePeriod: 1h
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/
// © venkyrocker7777

//@version=5

strategy('Donchain channel based investment strategy', shorttitle='Donchain channel strategy', overlay=true)

Length = input.int(21, minval=1)
xPrice = close
xvnoise = math.abs(xPrice - xPrice[1])
nAMA = 0.0
nfastend = 0.666
nslowend = 0.0645
nsignal = math.abs(xPrice - xPrice[Length])
nnoise = math.sum(xvnoise, Length)
nefratio = nnoise != 0 ? nsignal / nnoise : 0
nsmooth = math.pow(nefratio * (nfastend - nslowend) + nslowend, 2)
nAMA := nz(nAMA[1]) + nsmooth * (xPrice - nz(nAMA[1]))
plot(nAMA, color=color.new(color.blue, 0), title='KAMA')

// Function to get Lower Channel, Upper Channel, Middle Channel for a period length
getLCUCMC(PeriodLength) =>
    lowestValueInThePeriod = ta.lowest(PeriodLength)  // LC
    highestValueInThePeriod = ta.highest(PeriodLength)  // UC
    middleChannelInTheperiod = math.avg(highestValueInThePeriod, lowestValueInThePeriod)  // MC
    // Returns Lower Channel, Upper Channel, Middle Channel for a period length
    [lowestValueInThePeriod, highestValueInThePeriod, middleChannelInTheperiod]

// Longer time frame for entry
longerPeriod = 52

// Shorter time frame for exit
shorterPeriod = 12

if timeframe.period == 'D'
    // Longer time frame for entry
    longerPeriod := 52 * 5

    // Shorter time frame for exit
    shorterPeriod := 12 * 5
    shorterPeriod

if timeframe.period == 'M'
    // Longer time frame for entry
    longerPeriod := 12

    // Shorter time frame for exit
    shorterPeriod := 3
    shorterPeriod

// Get Lower Channel, Upper Channel, Middle Channel for longerPeriod, shorterPeriod
[lowestValueInTheLongerPeriodLength, highestValueInTheLongerPeriodLength, middleChannelInLongerperiod] = getLCUCMC(longerPeriod)
[lowestValueInTheShorterPeriodLength, highestValueInTheShorterPeriodLength, middleChannelInShorterperiod] = getLCUCMC(shorterPeriod)


// Plot Upper Channel of longerPeriod in dark green
plot(highestValueInTheLongerPeriodLength, 'highestValueInTheLongerPeriodLength', color=color.new(color.green, 0))

// Plot Lower Channel of shorterPeriod in dark red
plot(lowestValueInTheShorterPeriodLength, 'lowestValueInTheShorterPeriodLength', color=color.new(color.red, 0))

// Entry Plan
// Will start to see if we can enter when high crosses up longer period high (high >= highestValueInTheLongerPeriodLength)
// Check if any of the three past candles and enter when any of the 3 past candles satisfy
// 1) high of that candle >= highestValueInTheLongerPeriodLength of that candle (high[i] >= highestValueInTheLongerPeriodLength[i])
// 2) close of entry point consideration candle is above close of that candle (close > close[i])
isThisPointAnEntry() =>
// Check last 3 bars
    isThisPointAnEntry = false
    offset = 0
    for i = 1 to 3 by 1
        isCurrentCandleALongerPeriodHigh = high >= highestValueInTheLongerPeriodLength
        isCurrentCandleCloseGreaterThanPreiousIthOne = close > close[i]
        isPreviousIthCandleAlsoALongerPeriodHigh = high[i] >= highestValueInTheLongerPeriodLength[i]
        isThisPointAnEntry := isCurrentCandleALongerPeriodHigh and isCurrentCandleCloseGreaterThanPreiousIthOne and isPreviousIthCandleAlsoALongerPeriodHigh
        if isThisPointAnEntry
            offset := -i
            break
    [isThisPointAnEntry, offset]

// Exit Plan - same as entry plan, with things reversed and also on a shorter time frame
// Will start to see if we should exit when low crosses down longer period low (low <= lowestValueInTheShorterPeriodLength)
// Check if any of the three past candles and exit when any of the 3 past candles satisfy
// 1) low of that candle <= highestValueInTheLongerPeriodLength of that candle (low[i] <= lowestValueInTheShorterPeriodLength[i])
// 2) close of exit point consideration candle is below close of that candle (close < close[i])
isThisPointAnExit() =>
// Check last 3 bars
    isThisPointAnExit = false
    for i = 1 to 3 by 1
        isCurrentCandleAShorterPeriodLow = low <= lowestValueInTheShorterPeriodLength
        isCurrentCandleCloseLesserThanPreiousIthOne = close < close[i]
        isPreviousIthCandleAlsoAShorterPeriodLow = low[i] <= lowestValueInTheShorterPeriodLength[i]
        isThisPointAnExit := isCurrentCandleAShorterPeriodLow and isCurrentCandleCloseLesserThanPreiousIthOne and isPreviousIthCandleAlsoAShorterPeriodLow
        break
    isThisPointAnExit

[isEntry, offset] = isThisPointAnEntry()


if isEntry
    strategy.entry('Buy', strategy.long)

strategy.close_all(when=isThisPointAnExit() == true)

if year(timenow) == year(time) and month(timenow) == month(time) and dayofmonth(timenow) - 2 == dayofmonth(time)
    strategy.close_all()

Plus de

2019 FMZ - Tous les droits réservés