
A estratégia de pirâmide de pedra dura é uma estratégia de negociação quantitativa que segue a lei de negociação de pirâmide de Brady. Ela usa entradas de ruptura de preço, parada de perdas para rastrear saídas de parada, calcula o tamanho da posição de acordo com a amplitude real da onda e controla rigorosamente a perda de uma só moeda.
A estratégia de piratas de pedra dura é a entrada de ruptura. Especificamente, ela calcula o preço máximo e o preço mínimo em um determinado período de tempo com base nos parâmetros de ciclo de ruptura de entrada. Quando o preço supera o preço máximo, faça uma entrada adicional; Quando o preço supera o preço mínimo, faça uma entrada em branco.
Por exemplo, se o parâmetro de ciclo de entrada for definido como 20 linhas K, a estratégia extrairá o preço mais alto e o preço mais baixo das 20 linhas K mais recentes. Se o preço de fechamento da linha K atual for maior do que o preço mais alto das 20 linhas K anteriores, a estratégia emitirá mais pedidos de parada na posição de preço de fechamento, esperando que o preço de entrada ultrapasse o preço mais alto.
A estratégia de piratas de pedra dura em stop loss tracking stop loss exit. De acordo com os parâmetros de ciclo de saída de entrada, ele calcula dinamicamente o preço máximo e mínimo em um determinado período. Isso se torna o canal de saída da estratégia.
Quando uma posição é mantida, se o preço for abaixo do preço mais baixo de saída do canal, a posição é retirada. Por outro lado, quando uma posição é mantida em aberto, se o preço for acima do preço mais alto de saída do canal, a posição é retirada.
Além disso, a estratégia também calcula o ponto de parada com base na amplitude real, como a última linha de parada. Desde que o preço não quebre o canal de saída, o ponto de parada continuará a acompanhar a correção, garantindo que a distância de parada seja adequada, não seja excessivamente radical e não cause perdas desnecessárias, nem seja muito distante para controlar efetivamente a perda.
A estratégia de piratas de pedra calcula o tamanho de uma única posição com base na amplitude real da onda. Concretamente, primeiro calcula a porcentagem de perda potencial perto do preço de entrada e, em seguida, retorna o tamanho da posição com base nos parâmetros de risco esperados. Isso permite controlar efetivamente a perda máxima por transação.
A estratégia de Piratas do Rock segue as regras de negociação de Piratas do Brady, aplicando rigorosamente as regras de entrada e saída, sem variações arbitrárias. Isso permite que a estratégia funcione de forma estável a longo prazo, sem que o sistema falhe devido a erros de julgamento temporários.
A estratégia adota o método de entrada de ruptura de preço, que pode evitar efetivamente o risco de entrada de falha em níveis elevados, reduzindo assim a possibilidade de perda sistemática. Ao mesmo tempo, o método de parada de rastreamento de perdas garante o controle de perdas individuais e limita ao máximo a reversão causada por perdas contínuas.
A estratégia de calcular a posição com a amplitude real da onda, controlar rigorosamente a perda máxima de cada transação dentro do limite permitido, evitar o excesso de risco causado por grandes perdas individuais. Ao mesmo tempo, adotar o método de rastreamento de stop loss para garantir que a distância de parada seja adequada, pode parar os perdas em tempo hábil e controlar o risco de forma eficaz.
Se a ruptura de tremor não for conduzida, é fácil formar um falso sinal que causa perda de entrada errada do sistema. Nesse caso, é necessário ajustar os parâmetros, aumentar as condições de confirmação de entrada e evitar a interferência sonora da ruptura inativa.
Os parâmetros da estratégia, como o ciclo de entrada, o ciclo de saída, etc., são configurados estaticamente. Se houver uma grande mudança no ambiente do mercado, esses parâmetros podem ser invalidados.
A estratégia usa indicadores técnicos como flags de ruptura de preço. Quando as tendências do mercado e os padrões de flutuação mudam significativamente, esses indicadores técnicos podem ser inoperantes.
Pode-se adicionar a estratégia de indicadores de tendência de uso comum, como MA, MACD, etc. Quando você faz mais, julgue a tendência de alta, quando você faz a tendência de baixa, você pode reduzir a perda de operação de reversão.
Pode-se introduzir indicadores técnicos de um quadro de tempo de nível superior para um julgamento integrado. Por exemplo, a posição da linha MA no nível 86400 pode determinar a direção geral do movimento, confirmando ainda mais os sinais de operação no gráfico cronometrado.
Pode-se usar métodos como aprendizado de máquina para otimizar automaticamente os parâmetros com base em dados históricos e ajustar os parâmetros em tempo real para adaptá-los às mudanças no ambiente de mercado. Isso pode tornar a estratégia mais adaptável e estável.
A estratégia de pirâmide de pedra dura segue as regras clássicas de negociação de pirâmide, com entrada de ruptura de preço e parada de rastreamento de parada de perda, controle rigoroso de risco, pode operar com estabilidade a longo prazo e ter excelente capacidade de resistência à queda e retorno. Embora ainda seja necessário prevenir alguns riscos, como falha de ruptura e falha de parâmetros, os meios de introdução de julgamento de tendência, julgamento de quadro de tempo e otimização de parâmetros dinâmicos podem reduzir efetivamente esses riscos, aumentando significativamente a capacidade de operação estável 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)