O recurso está a ser carregado... Carregamento...

Estratégia de negociação de ruptura do canal de Donchian

Autora:ChaoZhang, Data: 2023-11-08 12:31:56
Tags:

Resumo

A estratégia de negociação de breakout do canal Donchian julga as tendências de preços atuais calculando o canal dos preços mais altos e mais baixos em um determinado período e negociações longas e curtas com base em breakouts de canal.

Estratégia lógica

Esta estratégia constrói um canal calculando o preço mais alto pcmax e o preço mais baixo pcmin nos últimos períodos históricos.

Equipamento de ensaio de veículos

Relhas inferiores yl = pcmin + (pcmax - pcmin) * %Dev/100

onde o percentualDev está definido como 13.

Um sinal longo é gerado quando o preço quebra o trilho superior. Um sinal curto é gerado quando o preço quebra o trilho inferior.

A lógica específica para gerar sinais de negociação é:

boundup = high > yh para determinar se o carril superior está quebrado
bounddn = low < yl para determinar se o carril inferior está quebrado
upsign = sma(bounddn, 2) == 1 usa sma de bounddn para determinar a ruptura persistente do trilho inferior
dnsign = sma(boundup, 2) == 1 usa sma de boundup para determinar a ruptura persistente do trilho superior
saída = dnsign ruptura do carril superior gera sinal de saída
Exitdn = ruptura do sinal superior do carril inferior gera sinal de saída
Se o sinal de alta velocidade do trilho inferior gerar sinal longo
Se o sinal de sinal de ruptura do carril superior gerar sinal curto

A estratégia também define os horários de início e de término das negociações para evitar posições overnight desnecessárias.

Vantagens da estratégia

Usa o canal Donchian para determinar tendências, bons resultados de backtest
Tem sinais longos e curtos, permite negociação bidirecional
Usa a SMA para filtrar sinais e evitar maus negócios
Ativos de capital de risco
Determina os horários de início e de encerramento das negociações para evitar riscos overnight

Riscos da Estratégia

Sensível ao histórico e percentual de parâmetros Dev, precisa de otimização para diferentes produtos
Pode gerar sinais falsos em mercados de gama
Não considera o gerenciamento de ordens, pode afetar a lucratividade na negociação ao vivo
Não considera o dimensionamento das posições, riscos de posições de grande dimensão
Não considera a gestão de fundos, necessita de um capital comercial razoável

Ideias de melhoria

Otimizar parâmetros de histórico e percentDev para diferentes produtos
Adicionar filtros para evitar sinais falsos em mercados variados
Adicionar módulo de dimensionamento de posição para controlar o tamanho de posição única
Adicionar módulo de gestão de fundos para limitar o tamanho total da posição
Adicionar gerenciamento de ordens para execução de ordens ideal

Conclusão

A estratégia de breakout do canal Donchian usa breakouts de canal para determinar tendências e sinais de negociação, com bons resultados de backtest e capacidade de negociar longo e curto. No entanto, existem riscos em relação à otimização de parâmetros, filtros, dimensionamento de posição, gerenciamento de dinheiro, gerenciamento de ordens, etc. Melhorias adequadas nessas áreas são necessárias antes de uma negociação estável.

/*backtest
start: 2023-10-31 00:00:00
end: 2023-11-07 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

////////////////////////////////////////////////////////////
//  Copyright by AlexInc v1.0 02/07/2018  @aav_1980
// PriceChannel strategy
// If you find this script helpful, you can also help me by sending donation to 
// BTC 16d9vgFvCmXpLf8FiKY6zsy6pauaCyFnzS
// LTC LQ5emyqNRjdRMqHPHEqREgryUJqmvYhffM
////////////////////////////////////////////////////////////
//@version=3
strategy("AlexInc PriceChannel Str", overlay=false)
history = input(20)
percentDev = input(13)
capital = input(100)

needlong = input(true, defval = true, title = "Long")
needshort = input(true, defval = true, title = "Short")
usestoploss = input(true, defval = true, title = "Stop Loss")
stoplossmult = input(3.8, defval = 3.8, minval = 1, maxval = 10, title = "Stop loss multiplicator")


fromyear = input(2018, defval = 2018, minval = 1900, maxval = 2100, title = "From Year")
toyear = input(2100, defval = 2100, minval = 1900, maxval = 2100, title = "To Year")
frommonth = input(01, defval = 01, minval = 01, maxval = 12, title = "From Month")
tomonth = input(12, defval = 12, minval = 01, maxval = 12, title = "To Month")
fromday = input(01, defval = 01, minval = 01, maxval = 31, title = "From day")
today = input(31, defval = 31, minval = 01, maxval = 31, title = "To day")

bodymin = min( open, close)
bodymax = max(open, close)

pcmax = highest(bodymax, history)
pcmin = lowest(bodymin, history)

yh = ((pcmax - pcmin) / 100 * (100 - percentDev)) + pcmin
yl = ((pcmax - pcmin) / 100 * percentDev) + pcmin

plot(pcmax)
plot(pcmin)
plot(yh)
plot(yl)

//1
bounddn = low < yl ? 1 : 0
boundup = high > yh ? 1 : 0
upsign = sma(bounddn, 2) == 1
dnsign = sma(boundup, 2) == 1
//2
//upsign = crossover(bodymin, yl)
//dnsign = crossunder(bodymax , yh)


exitup = dnsign
exitdn = upsign

lot = strategy.equity / close * capital / 100


xATR = atr(history)
nLoss = usestoploss ? stoplossmult * xATR : na

stop_level_long = 0.0
stop_level_long := nz(stop_level_long[1])

stop_level_short = 0.0
stop_level_short := nz(stop_level_short[1])

pos = strategy.position_size
if pos >0 and pos[1] <= 0 //crossover(pos, 0.5)
    stop_level_long = strategy.position_avg_price - nLoss
if pos < 0 and pos[1] >= 0 //crossunder(pos, -0.5)
    stop_level_short = strategy.position_avg_price + nLoss
if pos == 0    
    stop_level_long = bodymin - nLoss
    stop_level_short = bodymax + nLoss

//plot(bodymax + nLoss, color=red)
//plot(bodymin - nLoss, color=red)
plot(stop_level_long, color=red)
plot(stop_level_short, color=red)

if upsign
    strategy.entry("Long", strategy.long, needlong == false ? 0 : lot)

if dnsign
    strategy.entry("Short", strategy.short, needshort == false ? 0 : na)

if true
    strategy.close_all()


//if strategy.position_size != 0
//    strategy.exit("Exit Long", from_entry = "Long", stop = stop_level_long)
//    strategy.exit("Exit Short", from_entry = "Short", stop = stop_level_short)

Mais.