Strategi perdagangan berbasis saluran Donchain

Penulis:ChaoZhang, Tanggal: 2024-02-27 14:57:37
Tag:

Gambaran umum

Ini adalah strategi perdagangan yang memanfaatkan saluran Donchain selama beberapa kerangka waktu untuk menentukan titik masuk dan keluar.

Logika Strategi

Strategi ini terutama memanfaatkan konsep saluran Donchain, yang terdiri dari saluran atas, bawah dan garis tengah. lebar saluran bervariasi dalam jangka waktu yang berbeda. khususnya, kami membangun saluran Donchain dalam dua skala waktu:

Gunakan 52 periode untuk membangun saluran Donchain jangka panjang dan mendapatkan garis atas, bawah dan tengahnya.
Gunakan 12 periode untuk membangun saluran Donchain jangka pendek dan mendapatkan garis atas, bawah dan tengahnya.

Logika masuk: Ketika harga pecah di atas atas saluran jangka panjang, kita menentukan sebagai sinyal masuk panjang. Untuk menghindari pecah palsu, kita membutuhkan setidaknya 1 lilin dalam 3 terakhir ditutup di atas saluran atas.

Logika keluar: Ketika harga pecah di bawah bagian bawah saluran jangka pendek, kita menentukannya sebagai sinyal keluar untuk menutup posisi panjang.

Keuntungan

Strategi ini menggabungkan keuntungan dari kedua tren mengikuti dan rata-rata reversi perdagangan. kerangka waktu yang lebih lama menilai tren sementara kerangka waktu yang lebih pendek menangkap pembalikan lokal dalam tren.
Menggunakan analisis multi-frame waktu membantu mengatasi masalah dengan kebocoran palsu dan membuat entri/keluar lebih valid.
Parameter dapat dioptimalkan untuk produk dan rezim pasar yang berbeda.

Risiko & Solusi

Strategi ini sensitif terhadap parameter. parameter yang berbeda dapat menyebabkan hasil yang sangat berbeda. pengujian dan optimalisasi yang memadai diperlukan untuk menemukan set parameter yang optimal.
Hal ini dapat memicu perdagangan yang berlebihan di berbagai pasar. Stop loss harus digunakan untuk mengendalikan kerugian perdagangan tunggal.
Ini tidak mempertimbangkan sistem pasar secara keseluruhan. Mungkin gagal pada titik pembalikan tren utama. Indikator lain harus digunakan untuk mengukur tren utama.

Arahan Optimasi

Melakukan optimasi parameter untuk menemukan parameter terbaik, termasuk periode saluran, jenis saluran dll.
Masukkan logika stop loss dengan stop trailing yang wajar untuk mengendalikan kerugian.
Menggabungkan indikator lain untuk menentukan tren utama, seperti EMA, Saluran Keltner, MACD dll, menghindari kegagalan pada titik balik utama.

Kesimpulan

Secara singkat, ini adalah strategi penyebaran saluran Donchain multi-frame yang khas. Ini mengintegrasikan baik mengikuti tren dan reversi rata-rata dengan baik untuk menangkap pembalikan lokal dalam tren. Dengan parameter yang dioptimalkan, ini dapat berkinerja sangat baik di pasar tren. Namun, strategi itu sendiri rapuh, sensitif terhadap parameter dan rezim pasar secara keseluruhan. Disarankan untuk dikombinasikan dengan strategi atau indikator lain untuk mencapai hasil yang lebih kuat.

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

Lebih banyak

2019 FMZ - Semua hak dilindungi