Die Ressourcen sind geladen. Beförderung...

Handelsstrategie auf Basis von Donchain-Kanälen

Schriftsteller:ChaoZhang, Datum: 2024-02-27 14:57:37
Tags:

Übersicht

Dies ist eine Handelsstrategie, die Donchain-Kanäle über mehrere Zeitrahmen verwendet, um Ein- und Ausstiegspunkte zu bestimmen.

Strategie Logik

Die Strategie nutzt hauptsächlich das Konzept der Donchain-Kanäle, die aus den Kanal-Ober-, Unter- und Mittellinien bestehen.

Verwenden Sie 52 Perioden, um einen langfristigen Donchain-Kanal zu konstruieren und seine obere, untere und mittlere Linie zu erhalten.
Verwenden Sie 12 Perioden, um einen kürzerfristigen Donchain-Kanal zu konstruieren und seine obere, untere und mittlere Linie zu erhalten.

Eintrittslogik: Wenn der Preis über das langfristige Kanal-Oberteil bricht, bestimmen wir es als langes Eintrittssignal. Um falsche Ausbrüche zu vermeiden, benötigen wir mindestens 1 Kerze in den letzten 3 über dem Kanal-Oberteil geschlossen.

Ausgangslogik: Wenn der Preis unter den kurzfristigen Kanalboden bricht, bestimmen wir es als Ausgangssignal, um lange Positionen zu schließen.

Vorteile

Die Strategie kombiniert die Vorzüge sowohl des Trendfolgs als auch des mittleren Umkehrhandels. Der längere Zeitrahmen beurteilt den Trend, während der kürzere Zeitrahmen lokale Umkehrungen im Trend erfasst.
Die Verwendung von Multi-Timeframe-Analysen hilft, Probleme mit falschen Ausbrüchen zu beheben und macht Ein-/Ausgänge gültiger.
Die Parameter können für verschiedene Produkte und Marktregime optimiert werden.

Risiken und Lösungen

Die Strategie ist parametersensitiv. Verschiedene Parameter können zu drastisch unterschiedlichen Ergebnissen führen.
Es kann zu übermäßigen Trades in verschiedenen Märkten führen. Ein Stop Loss sollte verwendet werden, um Einzelhandelsverluste zu kontrollieren.
Es berücksichtigt nicht das allgemeine Marktregime. Es kann an wichtigen Trendumkehrpunkten fehlschlagen. Andere Indikatoren sollten zur Beurteilung des wichtigen Trends verwendet werden.

Optimierungsrichtlinien

Parameteroptimierung durchführen, um die besten Parameter zu finden, einschließlich Kanalzeiten, Kanaltypen usw.
Einbeziehung von Stop-Loss-Logik mit angemessenen Trailing-Stops zur Verlustkontrolle.
Kombination anderer Indikatoren zur Ermittlung des wesentlichen Trends, wie EMA, Keltner-Kanäle, MACD usw., um Fehler an wichtigen Wendepunkten zu vermeiden.

Schlussfolgerung

Zusammenfassend ist dies eine typische Multi-Timeframe-Donchain-Kanal-Breakout-Strategie. Sie integriert sowohl Trendfollowing als auch mittlere Umkehrung, um lokale Umkehrungen innerhalb von Trends zu erfassen. Mit optimierten Parametern kann sie sehr gut in Trendmärkten abschneiden. Die Strategie selbst ist jedoch fragil, empfindlich gegenüber Parametern und dem Gesamtmarktregime. Es wird empfohlen, sie mit anderen Strategien oder Indikatoren zu kombinieren, um robustere Ergebnisse zu erzielen.

/*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()

Mehr