Estratégia de comércio de tartarugas

Autora:ChaoZhang, Data: 2023-12-25 17:12:05
Tags:

Resumo

A estratégia de negociação de tartaruga é uma estratégia de acompanhamento de tendências que rastreia breakouts de momento. Foi desenvolvida pelo famoso comerciante Richard Dennis na década de 1980 para provar que os comerciantes podem ser nutridos por regras em vez de nascidos. A ideia central da estratégia é rastrear breakouts de preços e seguir tendências, ao mesmo tempo em que se adere estritamente aos princípios de gerenciamento de dinheiro para limitar o risco de queda.

Estratégia lógica

A estratégia de negociação de tartaruga usa dois parâmetros N e N/2 para construir canais. Especificamente, calcula os preços mais altos e mais baixos nos últimos N dias e N/2 dias. Quando o preço excede o canal de N dias, uma posição longa é estabelecida. Quando o preço cai abaixo do canal de N/2 dias, a posição é fechada. Da mesma forma, quando o preço quebra o canal de N dias para o lado negativo, uma posição curta é estabelecida e fechada quando o preço sobe acima do canal de N/2 dias. O objetivo é seguir as tendências de preços enquanto controla o risco.

No código, N corresponde aenter_slowe N/2 corresponde aenter_fastOs preços mais elevados (slowLefastL) e preços mais baixos (slowSefastSAs posições longas são abertas quando o preço excede o canal de 55 dias (enterL2) e fechado quando o preço cai abaixo do canal de 20 dias (exitL1As posições curtas são abertas quando o preço ultrapassa o canal de 55 dias para baixo (enterS2) e fechado quando o preço ultrapassa o canal de 20 dias (exitS1).

Análise das vantagens

A maior vantagem da Estratégia de Negociação de Tartaruga é o controle de risco. Ao estabelecer posições em breakouts de preços e parar rapidamente em pullbacks, ele controla efetivamente as perdas em negócios individuais.

Outra vantagem é a simples seleção de parâmetros. Toda a estratégia tem apenas 4 parâmetros que são fáceis de entender e ajustar. Os parâmetros em si também são bastante estáveis, sem precisar de otimização frequente.

Análise de riscos

O maior risco da Estratégia de Negociação de Tartaruga é a incapacidade de rastrear tendências de longo prazo. Pode perder oportunidades de entrada quando as tendências começam a se formar. Além disso, em ambientes de oscilação de preços agitados, a estratégia desencadeará entradas e saídas frequentes, aumentando os custos de transação e os riscos de deslizamento.

Além disso, as definições dos parâmetros fixos podem funcionar de forma muito diferente entre os produtos e os regimes de mercado, exigindo uma regulação manual com base na experiência.

Oportunidades de melhoria

A estratégia de comércio de tartarugas pode ser reforçada de várias formas:

Adicionar capacidades de adaptação aos parâmetros N e N/2 com base na volatilidade do mercado e na frequência do sinal para tornar o sistema mais robusto em todos os cenários.
Incorporar regras de detecção de tendências antes da entrada para evitar entradas erradas em mercados agitados.
Adotar uma abordagem de vários prazos para confirmar as tendências em períodos mais elevados e realizar transações em períodos mais baixos.
Otimizar as regras de stop loss com trailing stops ou time-based stops para reduzir os drawdowns.

Conclusão

A estratégia de negociação de tartaruga rastreia efetivamente as tendências por um sistema de breakout simples. O controle de risco é sua maior força, graças a paradas rápidas e dimensionamento de posição fracionário fixo. Ao mesmo tempo, vemos múltiplas dimensões ao longo das quais a estratégia pode ser estendida e otimizada para se adequar a mais instrumentos e condições de mercado.

/*backtest
start: 2022-12-24 00:00:00
end: 2023-12-24 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=2
//oringinally coded by tmr0, modified by timchep
//original idea from «Way of the Turtle: The Secret Methods that Turned Ordinary People into Legendary Traders» (2007) CURTIS FAITH
strategy("Turtles", shorttitle = "Turtles", overlay=true, pyramiding=1, default_qty_type= strategy.percent_of_equity, default_qty_value = 100)
//////////////////////////////////////////////////////////////////////
// Component Code Start
testStartYear = input(2011, "Backtest Start Year")
testStartMonth = input(12, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)

testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)

// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=bool, defval=false)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
// Component Code Stop
//////////////////////////////////////////////////////////////////////

shortingEnabled = input(title="Enable Shorting?", type=bool, defval=true)

enter_fast = input(20, minval=1)
exit_fast = input(10, minval=1)
enter_slow = input(55, minval=1)
exit_slow = input(20, minval=1)

fastL = highest(enter_fast)
fastLC = lowest(exit_fast)
fastS = lowest(enter_fast)
fastSC = highest(exit_fast)

slowL = highest(enter_slow)
slowLC = lowest(exit_slow)
slowS = lowest(enter_slow)
slowSC = highest(exit_slow)

enterL1 = high > fastL[1] 
exitL1 = low <= fastLC[1] 
enterS1 = low < fastS[1]
exitS1 = high >= fastSC[1]

enterL2 = high > slowL[1] 
exitL2 = low <= slowLC[1] 
enterS2 = low < slowS[1]
exitS2 = high >= slowSC[1]


if testPeriod()
    strategy.entry("fast L", strategy.long, when = enterL1) 
    
    if not enterL1
        strategy.entry("slow L", strategy.long, when = enterL2)
        
    strategy.close("fast L", when = exitL1)
    strategy.close("slow L", when = exitL2)

if shortingEnabled and testPeriod()
    strategy.entry("fast S", strategy.short, when = enterS1)
    if not enterS2
        strategy.entry("slow S", strategy.short, when = enterS2)
        
    strategy.close("fast S", when = exitS1)
    strategy.close("slow S", when = exitS2)

Mais.