Estrategia de comercio en cuadrícula de Ocean Theory


Fecha de creación: 2023-10-13 17:07:39 Última modificación: 2023-10-13 17:07:39
Copiar: 0 Número de Visitas: 787
1
Seguir
1617
Seguidores

Descripción general

La estrategia utiliza el método de negociación de la red en la teoría de los océanos, en el rango de precios establecidos, distribuye uniformemente la red de líneas, en función de la relación entre el precio y la línea de la red de comprar y vender operaciones. La estrategia tiene el cálculo automático de las franjas de precios de la red, distribuye uniformemente la red de líneas, etc. características, puede controlar el riesgo de manera efectiva.

Principio de estrategia

La estrategia primero calcula los límites superiores y inferiores de la cuadrícula de precios, es decir, los precios máximos y mínimos de la cuadrícula, según la selección o configuración predeterminada por el usuario. Hay dos formas de calcular, una es encontrar los precios máximos y mínimos en el período de retroalimentación, y la segunda es calcular la media de un período determinado. Luego, la cuadrícula se distribuye uniformemente según el número de cuadrículas configuradas por el usuario.

La generación de señales de negociación depende de la relación entre el precio y la línea de la red. Cuando el precio está por debajo de la línea de la red, se abre una posición en la línea de la red por una cantidad fija; cuando el precio está por encima de la línea de la red, se cierra una posición en la línea de la red por una cantidad fija.

En concreto, la estrategia mantiene una matriz de precios de la línea de la grilla y una matriz de bool que indican si cada línea de la grilla tiene un alza. Cuando el precio está por debajo de una línea de la grilla y no tiene alza, el precio aumenta en esa línea; cuando el precio es más alto que una línea de la grilla y la línea de la grilla inferior tiene alza, la línea de la grilla inferior se estabiliza.

Ventajas estratégicas

  1. Calcula automáticamente el espacio de la rejilla, evitando la dificultad de la configuración manual. Se puede elegir un método de cálculo diferente.

  2. Distribución uniforme de las líneas de la red para evitar que la densidad de la red provoque una transacción excesiva. El número de líneas de la red es ajustable.

  3. El método de negociación de la grilla permite controlar el riesgo de manera efectiva, mientras que las fluctuaciones de los precios dentro de la grilla permiten obtener ganancias.

  4. No se espera una dirección para los precios, lo que se aplica en situaciones de crisis.

  5. La tarifa de operación y el número de posiciones se pueden configurar de forma personalizada para adaptarse a diferentes tipos de operaciones.

  6. La línea de la rejilla se muestra visualmente para facilitar la comprensión de las transacciones.

Riesgo estratégico

  1. Riesgo de ruptura de la zona de la rejilla. La ruptura del precio de la parte inferior de la rejilla puede provocar una expansión de las pérdidas.

  2. Riesgo de la distancia de la rejilla demasiado ancha. Una rejilla demasiado ancha es difícil de ganar, pero una demasiado estrecha aumenta las tarifas. Se debe hacer una contrapartida.

  3. El riesgo de mantener una posición durante demasiado tiempo. La tenencia de una posición durante mucho tiempo es difícil de obtener ganancias pero aumenta la pérdida de comisiones.

  4. Riesgo de configuración incorrecta de los parámetros. La configuración incorrecta de los parámetros, como el ciclo de retraso o el ciclo de la línea media, puede afectar el cálculo del intervalo de la red.

  5. Riesgo sistémico del mercado. Esta estrategia es más adecuada para situaciones de crisis que para situaciones unilaterales a largo plazo.

Optimización de la estrategia

  1. Optimización de la configuración de los parámetros de la rejilla. Consideración integral de las características del mercado, los costos de transacción y otros factores. Optimización de la cantidad de rejillas y otros parámetros.

  2. Ajuste dinámico de la zona de la rejilla. Cuando el mercado cambia mucho, se puede introducir un mecanismo de ajuste dinámico de la zona de la rejilla.

  3. Adherirse a un mecanismo de suspensión de pérdidas. Establecer una línea de suspensión razonable para evitar pérdidas excesivas. La línea de suspensión de pérdidas también se puede ajustar dinámicamente.

  4. En combinación con otros indicadores de filtración de operaciones, como líneas de browsing, indicadores de tendencias, etc., evita operaciones inadecuadas.

  5. Optimización de la eficiencia de la utilización de los fondos. Adición de análisis en frío y caliente para reducir las transacciones cuando la volatilidad es menor.

Resumir

La estrategia utiliza el principio de comercio de la rejilla, que permite el comercio de condiciones de movimiento con riesgo controlado. La estrategia tiene ventajas como la calculación automática de la rejilla, la distribución uniforme de la rejilla, que se puede adaptar a diferentes entornos de mercado mediante el ajuste de los parámetros. El riesgo es controlado y fácil de operar.

Código Fuente de la Estrategia
/*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)