Tartaruga-realEstratégia firme como uma tartaruga-das-rochas

Autora:ChaoZhang, Data: 2024-02-18 14:34:40
Tags:

Resumo

A estratégia é uma estratégia quantitativa de negociação que segue as regras da metodologia de negociação da tartaruga Brady. Ela usa a quebra de preço para entrar em posições e pára de rastrear paradas para sair. Ela calcula o tamanho da posição com base na verdadeira volatilidade e controla estritamente as perdas por negociação. A estratégia tem estabilidade de longo prazo em operação e forte tolerância a drawdowns, assim como rochas firmes.

Princípio

Regra de entrada

A estratégia Steadfast as a Rock Turtle entra em breakouts. Especificamente, calcula a maior alta e a menor baixa durante o período de retrospectiva especificado. Quando o preço quebra acima da maior alta, ele vai longo. Quando o preço quebra abaixo da menor baixa, ele vai curto.

Por exemplo, com um período de entrada definido em 20 bares, a estratégia extrai a maior alta e a menor baixa nos últimos 20 bares.

Regra de saída

A estratégia Steadfast como uma tartaruga de rocha sai com paradas de rastreamento de paradas.

Se se mantiver longo, uma vez que o preço cai abaixo do mínimo mais baixo do canal de saída, a posição vai parar.

Além disso, a estratégia calcula um nível de stop-loss com base na verdadeira volatilidade, que serve como a parada final.

Dimensão da posição

A estratégia Steadfast as a Rock Turtle mede suas posições com base na volatilidade real. Especificamente, primeiro estima a porcentagem de perda potencial perto do preço de entrada, em seguida, inverte calcula o tamanho da posição a partir do parâmetro de risco esperado. Isso controla efetivamente a perda máxima por comércio.

Análise das vantagens

Operação constante

Esta estratégia adere estritamente às regras clássicas de negociação de tartarugas em entradas e saídas sem modificações arbitrárias.

Resiliência à redução

Ao entrar em breakouts, a estratégia evita entradas supervalorizadas efetivamente, reduzindo a probabilidade de perdas do sistema.

Contaminabilidade dos riscos

Ao dimensionar com base na verdadeira volatilidade, a estratégia controla estritamente a perda máxima por negociação dentro da tolerância e, ao rastrear as distâncias de parada, pode cortar as perdas a tempo de conter os riscos de forma eficaz.

Análise de riscos

Risco de falha da avaria

Os parâmetros precisariam ser ajustados com mais regras de confirmação de entrada para evitar ruído de ruptura ineficaz.

Risco de otimização de parâmetros

Os parâmetros estáticos da estratégia, como os períodos de entrada/saída, podem tornar-se inválidos se o regime do mercado mudar drasticamente.

Risco de falha do indicador técnico

Os indicadores utilizados como sinalizadores de ruptura de preços podem falhar quando a tendência ou a volatilidade mudam significativamente.

Orientações de otimização

Adicionar Filtro de Tendência

Indicadores de tendência comuns como MA, MACD podem ser adicionados.

Síntese do quadro de tempo

Os indicadores de prazo mais longo, por exemplo, os níveis diários de MA, podem ajudar a confirmar a direção geral para complementar os sinais de prazo mais curto.

Ajuste dinâmico de parâmetros

O aprendizado de máquina pode atualizar automaticamente os parâmetros da estratégia continuamente com base nos dados mais recentes para manter a eficácia na mudança da dinâmica do mercado.

Resumo

A estratégia de Steadfast as a Rock Turtle segue a metodologia clássica de negociação de tartarugas, seguindo estritamente a entrada de ruptura e a saída de parada de rastreamento com controle de risco rigoroso. Isso permite operações estáveis de longo prazo com forte resiliência de retirada. Apesar de riscos como ruptura falsa, falha de parâmetros, etc., estes podem ser mitigados efetivamente por meio de adições como filtro de tendência, síntese de prazo, ajuste dinâmico, etc. para melhorar significativamente a estabilidade da estratégia.

/*backtest
start: 2024-01-18 00:00:00
end: 2024-02-17 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=3
strategy("Real Turtle", shorttitle = "Real Turtle", overlay=true, pyramiding=1, default_qty_type= strategy.percent_of_equity,calc_on_order_fills=false, slippage=25,commission_type=strategy.commission.percent,commission_value=0.075)
//////////////////////////////////////////////////////////////////////
// Testing Start dates
testStartYear = input(2016, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
//Stop date if you want to use a specific range of dates
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
// Use if using a specific date range
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
//////////////////////////////////////////////////////////////////////

//How many candles we want to determine our position entry
enterTrade = input(20, minval=1, title="Entry Channel Length")
//How many candles we want ot determine our position exit
exitTrade = input(10, minval=1, title="Exit Channel Length")

//True Range EMA Length
trLength = input(13, minval=1, title="True Range Length")
//Go all in on every trade
allIn = input(false, title="Use whole position on every trade")
dRisk = input(2, "Use Desired Risk %")
//How much of emaTR to use for TS offset
multiEmaTR = input(2, "Desired multiple of ema Tr (N)")
//absolute value (highest high of of this many candles - lowest high of this many candles) . This is used if we want to change our timeframe to a higher timeframe otherwise just works like grabbing high o r low of a candle
//True range is calculated as just high - low. Technically this should be a little more complicated but with 24/7 nature of crypto markets high-low is fine.
trueRange = max(high - low, max(high - close[1], close[1] - low))
//Creates an EMA of the true range by our custom length
emaTR = ema(trueRange, trLength)
//Highest high of how many candles back we want to look as specified in entry channel for long
longEntry = highest(enterTrade)
//loweest low of how many candles back we want to look as specified in exit channel for long
exitLong = lowest(exitTrade)
//lowest low of how many candles back want to look as specified in entry channel for short
shortEntry = lowest(enterTrade)
//lowest low of how many candles back want to look as specified in exit channel for short
exitShort = highest(exitTrade)
//plots the longEntry as a green line
plot(longEntry[1], title="Long Entry",color=green)
//plots the short entry as a purple line
plot(shortEntry[1], title="Short Entry",color=purple)

howFar = barssince(strategy.position_size == 0)
actualLExit = strategy.position_size > 0 ? strategy.position_avg_price - (emaTR[howFar] * multiEmaTR) : longEntry - (emaTR * multiEmaTR)
actualLExit2 = actualLExit > exitLong ? actualLExit : exitLong
actualSExit = strategy.position_size < 0 ? strategy.position_avg_price + (emaTR[howFar] * multiEmaTR) : shortEntry + (emaTR * multiEmaTR)
actualSExit2 = actualSExit < exitShort ? actualSExit : exitShort

//plots the long exit as a red line
plot(actualLExit2[1], title="Long Exit",color=red)
//plots the short exit as a blue line
plot(actualSExit2[1], title="Short Exit",color=yellow)


//Stop loss in ticks
SLLong =(emaTR * multiEmaTR)/ syminfo.mintick
SLShort = (emaTR * multiEmaTR)/ syminfo.mintick


//Calculate our potential loss as a whole percentage number. Example 1 instead of 0.01 for 1% loss. We have to convert back from ticks to whole value, then divided by close
PLLong = ((SLLong * syminfo.mintick) * 100) / longEntry
PLShort = ((SLShort * syminfo.mintick) * 100) / shortEntry
//Calculate our risk by taking our desired risk / potential loss. Then multiple by our equity to get position size. we divide by close because we are using percentage size of equity for quantity in this script as not actual size.
//we then floor the value. which is just to say we round down so instead of say 201.54 we would just input 201 as TV only supports whole integers for quantity.
qtyLong = floor(((dRisk / PLLong) * strategy.equity) /longEntry )
qtyShort = floor(((dRisk / PLShort) * strategy.equity) /shortEntry )
qtyLong2 = allIn ? 100 : qtyLong
qtyShort2 = allIn ? 100 : qtyShort
//Only open long or short positions if we are inside the test period specified earlier
if testPeriod()
    //Open a stop market order at our long entry price and keep it there at the quantity specified. This order is updated/changed on each new candlestick until a position is opened
    strategy.entry("long", strategy.long, stop = longEntry, qty = qtyLong2) 
    //sets up or stop loss order by price specified in our actualLExit2 variable
    strategy.exit("Stoploss-Long", "long", stop=actualLExit2)
    
     //Open a stop market order at our short entry price and keep it there at the quantity specified. This order is updated/changed on each new candlestick until a position is opened
    strategy.entry("short", strategy.short, stop = shortEntry, qty = qtyShort2)
    //sets up or stop loss order by price specified in our actualLExit2 variable
    strategy.exit("Stoploss-Short", "short", stop=actualSExit2)

Mais.