Estratégia de negociação de grade da teoria oceânica
ChaoZhang
Visão geral
A estratégia usa o método de negociação de grelha da teoria oceânica, uma grelha distribuída uniformemente dentro de um intervalo de preços definido, fazendo compras e vendas de acordo com a relação entre o preço e a grelha. A estratégia tem características como o cálculo automático do intervalo de preços da grelha e a grelha distribuída uniformemente, o que permite controlar o risco de forma eficaz.
Princípio da estratégia
A estratégia primeiro calcula os limites superiores e inferiores da grelha de preços, ou seja, os preços mais altos e mais baixos da grelha, de acordo com a escolha ou configuração padrão do usuário. Há dois métodos de cálculo, um é encontrar os preços mais altos e mais baixos no período de retrospecção e o outro é calcular a média de um determinado período.
A geração de sinais de negociação depende da relação entre o preço e a linha da grelha. Quando o preço está abaixo da linha da grelha abaixo, o posicionamento é aberto em uma quantidade fixa na linha da grelha; Quando o preço está acima da linha da grelha acima, o posicionamento é fechado em uma quantidade fixa na linha da grelha. Assim, com a oscilação do preço, a posição também oscila dentro da grelha, gerando lucro.
Concretamente, a estratégia mantém uma matriz de preço de uma linha de grade e uma matriz de bool para indicar se cada linha de grade tem uma oferta pendente. Quando o preço está abaixo de uma determinada linha de grade e a linha não tem uma oferta pendente, o preço é mais alto nessa linha; Quando o preço é mais alto do que uma determinada linha de grade e a linha de grade abaixo tem uma oferta pendente, a linha de grade abaixo é plana.
Vantagens estratégicas
O cálculo automático do intervalo de grade evita a dificuldade de configuração manual. Pode-se escolher um método de cálculo diferente.
A rede é distribuída uniformemente, evitando a densidade da rede que leva a transações excessivas. O número de linhas da rede pode ser ajustado.
O método de negociação em grelha permite controlar o risco de forma eficaz, enquanto as flutuações de preços dentro da grelha permitem lucrar.
Não há previsão de direção para o preço, e isso é válido em situações de turbulência.
A taxa de transação e o número de posições podem ser configurados de acordo com o tipo de transação.
A linha de grade é visível e facilita a compreensão das transações.
Risco estratégico
Risco de ruptura da grelha. A ruptura do limite inferior da grelha pode aumentar os prejuízos.
Risco de uma grelha muito larga. Uma grelha muito larga dificulta a lucratividade, mas uma grelha muito estreita aumenta a taxa de processamento.
Risco de longo prazo. É difícil lucrar com a posse de longo prazo, mas aumenta a perda de comissões.
Risco de configuração incorreta dos parâmetros. A configuração incorreta dos parâmetros, como o período de retrospecção ou o período de mediana, pode afetar o cálculo do intervalo de grade.
Risco sistêmico de mercado. Esta estratégia é mais adequada para situações de turbulência do que para situações unilaterais de longo prazo.
Otimização de Estratégia
Optimizar a configuração dos parâmetros da grade. Considere fatores como características do mercado, custos de transação, número de grades e períodos de retomada.
Ajustamento dinâmico entre as grades. Quando o mercado muda muito, pode-se introduzir um mecanismo de ajuste dinâmico entre as grades.
Acompanhe o mecanismo de suspensão de prejuízos. Defina uma linha de suspensão razoável para evitar perdas excessivas. A linha de suspensão de prejuízos também pode ser ajustada dinamicamente.
Combine com outros indicadores para filtrar as transações. Como linhas de Brin, indicadores de tendência, etc., para evitar transações inadequadas.
Optimizar a eficiência do uso dos fundos. Adicionar análise a quente e frio, reduzir as transações quando há menos volatilidade.
Resumir
A estratégia utiliza o princípio de negociação de grades, para realizar negociações de cenários de turbulência com risco controlado. A estratégia tem vantagens como a grelha de cálculo automático, a grelha de distribuição uniforme e pode ser adaptada a diferentes ambientes de mercado por meio do ajuste de parâmetros. O risco é controlado e fácil de operar.
/*backtest
start: 2023-09-12 00:00:00
end: 2023-10-12 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("(IK) Grid Script", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool) // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"]) // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1) // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound = input(group="Grid Bounds", title="(Manual) Upper Boundry", defval=0.285, type=input.float) // for manual grid bounds only. The upperbound price of your grid
i_lowerBound = input(group="Grid Bounds", title="(Manual) Lower Boundry", defval=0.225, type=input.float) // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty = input(group="Grid Lines", title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer) // how many grid lines are in your grid
strategy.initial_capital = 50000
f_getGridBounds(_bs, _bl, _bd, _up) =>
if _bs == "Hi & Low"
_up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl) * (1 - _bd)
else
avg = sma(close, _bl)
_up ? avg * (1 + _bd) : avg * (1 - _bd)
f_buildGrid(_lb, _gw, _gq) =>
gridArr = array.new_float(0)
for i=0 to _gq-1
array.push(gridArr, _lb+(_gw*i))
gridArr
f_getNearGridLines(_gridArr, _price) =>
arr = array.new_int(3)
for i = 0 to array.size(_gridArr)-1
if array.get(_gridArr, i) > _price
array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
array.set(arr, 1, i == 0 ? i : i-1)
break
arr
var upperBound = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound // upperbound of our grid
var lowerBound = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth = (upperBound - lowerBound)/(i_gridQty-1) // space between lines in our grid
var gridLineArr = f_buildGrid(lowerBound, gridWidth, i_gridQty) // an array of prices that correspond to our grid lines
var orderArr = array.new_bool(i_gridQty, false) // a boolean array that indicates if there is an open order corresponding to each grid line
var closeLineArr = f_getNearGridLines(gridLineArr, close) // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0) // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1) // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
for i = 0 to (array.size(gridLineArr) - 1)
if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
buyId = i
array.set(orderArr, buyId, true)
strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
if close > array.get(gridLineArr, i) and i != 0
if array.get(orderArr, i-1)
sellId = i-1
array.set(orderArr, sellId, false)
strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))
if i_autoBounds
upperBound := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
lowerBound := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
gridWidth := (upperBound - lowerBound)/(i_gridQty-1)
gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)
closeLineArr := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)