Handelsstrategie basierend auf dem mehrskaligen schrittweisen Donqi-Kanal
ChaoZhang
Überblick
Es handelt sich um eine Handelsstrategie, bei der die Ein- und Ausstiegspunkte über mehrere Zeitskalen ermittelt werden. Die Hauptidee der Strategie lautet: Auf einer längeren Zeitskala ermitteln Sie die Richtung des Trends und finden Sie die Eintrittszeit; auf einer kürzeren Zeitskala ermitteln Sie die Trendwende und finden Sie die Ausstiegszeit.
Strategieprinzip
Die Strategie nutzt hauptsächlich das Konzept des Tongzhi-Kanals. Der Tongzhi-Kanal besteht aus einer oberen, unteren und mittleren Linie des Kanals. Die Gangbreite variiert mit den Zeitskalen.
- Mit 52-Zyklen erstellt man einen Tongzhi-Kanal mit einem längeren Zeitmaßstab, der die oberen, unteren und mittleren Linien des Kanals enthält.
- Konstruieren Sie einen Tanger-Kanal mit einem kürzeren Zeitmaßstab von 12 Zyklen, um eine Ober-, Unter- und Mittellinie zu erhalten
Eintrittslogik: Eintrittsmomente werden als mehrspurig bewertet, wenn der Preis die Oberseite eines längeren Skalakanals durchbricht. Um einen Falschbruch zu vermeiden, verlangen wir, dass mindestens eine der letzten drei K-Linien einen Schlusskurs hat, der über der Oberseite des Kanals dieser K-Line liegt. Dies verhindert einen Falschbruch durch eine übermäßige kurzfristige Expansion.
Exit-Logik: Es ist ein Ausgangsschlag, wenn der Preis die untere Grenze des kürzeren Zeitskalakanals überschreitet. Wir fordern außerdem, dass mindestens eine der letzten drei K-Linien mit einem Schlusskurs unter der unteren Grenze der K-Linie liegt, um die Wirksamkeit des Durchbruchs zu bestätigen und zu verhindern, dass es zu einer Schlinge kommt.
Strategische Vorteile
Die Strategie kombiniert die Vorteile von Trend-Tracking und Reversal-Trading. Die längere Zeitskala beurteilt die Richtung des Trends, die kürzere Zeitskala beurteilt die lokale Reversal, die in Kombination lokaler Schwankungen im Trend erfasst werden können.
Die Verwendung von mehrfachen Zeitmessungen zur besseren Bewältigung von Falschbrüchen macht Ein- und Ausstiegsprobleme deutlich effektiver.
Durch die Optimierung der Parameter kann sie an verschiedene Sorten und Marktumgebungen angepasst werden.
Risiken und Lösungen
Die Strategie ist sehr parametersensibel und kann mit unterschiedlichen Parametern völlig unterschiedliche Ergebnisse erzielen. Um die optimale Kombination von Parametern zu finden, müssen die Optimierungen ausgiebig getestet werden.
In einem konjunkturellen Umfeld kann die Strategie zu einer Überhöhung der Handelssignale führen. Ein einzelner Verlust kann durch die Konfiguration von Stop Losses kontrolliert werden.
Die Strategie berücksichtigt nicht die Trendentscheidungslogik auf der großen Ebene und kann an den Bull-Bear-Wechselpunkten fehlschlagen. Sie kann in Kombination mit anderen Indikatoren für die Beurteilung der Entwicklung auf der großen Ebene verwendet werden.
Optimierungsrichtung
Optimierung der Parameter, um die optimale Kombination von Parametern zu finden. Parameter wie die Länge der Optimierungsphase, die Art des Kanals usw.
Erhöhung der Stop-Loss-Logik. Konfigurieren Sie einen angemessenen mobilen Stop-Loss und kontrollieren Sie den Einzelschaden.
In Kombination mit anderen Indikatoren, um große Trends zu beurteilen, z. B. EMA, K-Linie-Kanal, Mack-Indikator usw. Vermeiden Sie Misserfolge an wichtigen Wendepunkten.
Zusammenfassen
Die Strategie ist im Allgemeinen eine typische mehrzeitige Kanal-Breakout-Strategie. Sie kombiniert die Vorteile von Trendverfolgung und Reversal-Trading gut, um lokale Schwankungen in Trends durch Kanal-Beschlüsse auf verschiedenen Zeitskalen zu erfassen. Wenn die Parameter optimiert sind, ist die Wirkung in trendigen Märkten hervorragend.
/*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()