En la carga de los recursos... Cargando...

Estrategia de negociación basada en el canal de Donchain

El autor:¿ Qué pasa?, Fecha: 2024-02-27 14:57:37
Las etiquetas:

Resumen general

Esta es una estrategia de trading que utiliza canales Donchain en múltiples marcos de tiempo para determinar los puntos de entrada y salida.

Estrategia lógica

La estrategia aprovecha principalmente el concepto de canales Donchain, que consiste en las líneas superiores, inferiores y medias del canal.

Utilice 52 períodos para construir un canal Donchain a largo plazo y obtener su línea superior, inferior y media.
Utilice 12 períodos para construir un canal Donchain a corto plazo y obtener su línea superior, inferior y media.

Lógico de entrada: cuando el precio se rompe por encima de la parte superior del canal a largo plazo, lo determinamos como una señal de entrada larga.

Lógica de salida: Cuando el precio se rompe por debajo del fondo del canal a corto plazo, lo determinamos como una señal de salida para cerrar posiciones largas.

Ventajas

La estrategia combina los méritos tanto de la tendencia de seguimiento como de la inversión media.
El uso de análisis de marcos de tiempo múltiples ayuda a abordar los problemas con las fallas y hace que las entradas/salidas sean más válidas.
Los parámetros se pueden optimizar para diferentes productos y regímenes de mercado.

Riesgos y soluciones

La estrategia es sensible a los parámetros. Diferentes parámetros pueden dar lugar a resultados drásticamente diferentes. Se necesitan pruebas y optimización adecuadas para encontrar el conjunto óptimo de parámetros.
Puede desencadenar operaciones excesivas en mercados variados. Se debe utilizar un stop loss para controlar la pérdida de una sola operación.
No tiene en cuenta el régimen general del mercado. Puede fallar en los puntos de inversión de tendencia más importantes.

Direcciones de optimización

Realizar una optimización de parámetros para encontrar los mejores parámetros, incluidos los períodos de canal, los tipos de canal, etc.
Incorporar una lógica de stop loss con paradas de trailing razonables para controlar la pérdida.
Combinar otros indicadores para determinar la tendencia principal, como la EMA, los canales de Keltner, el MACD, etc., evitando fallas en los puntos clave.

Conclusión

En resumen, esta es una estrategia típica de ruptura de canal Donchain de varios marcos de tiempo. Integra bien tanto el seguimiento de tendencias como la reversión media para capturar las reversiones locales dentro de las tendencias. Con parámetros optimizados, puede funcionar muy bien en los mercados de tendencias. Sin embargo, la estrategia en sí es frágil, sensible a los parámetros y al régimen general del mercado. Se recomienda combinarla con otras estrategias o indicadores para lograr resultados más robustos.

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

Más.