Esta estrategia utiliza el método de negociación de la red en la teoría del océano para colocar órdenes de compra y venta dentro de un rango de precios preestablecido.
La estrategia primero calcula los límites superior e inferior de la cuadrícula de precios en función de la elección del usuario o la configuración predeterminada. Hay dos formas de cálculo: obtener los precios más altos y más bajos en el período de backtesting, o calcular promedios móviles en un marco de tiempo. Luego, las líneas de cuadrícula se distribuyen uniformemente de acuerdo con el número de cuadrículas establecidas por el usuario.
Las señales comerciales se generan en función de la relación entre el precio y las líneas de la red. Cuando el precio está por debajo de una línea de la red, se abre una posición larga al precio de la línea de la red con una cantidad fija; cuando el precio va por encima de una línea de la red, la posición se cierra en la línea de la red debajo. A medida que el precio fluctúa dentro de la red, las posiciones cambian en consecuencia para obtener ganancias.
Específicamente, la estrategia mantiene una matriz de precios de línea de cuadrícula y una matriz de bool que indica si se colocan órdenes en cada línea. Cuando el precio está por debajo de una línea sin órdenes, se abre una posición larga en la línea; cuando el precio está por encima de una línea mientras existen órdenes en la línea inferior, las posiciones se cierran en la línea inferior.
El rango de la rejilla se calcula automáticamente, evitando la dificultad de ajuste manual.
Las líneas de la red se distribuyen de manera uniforme para evitar el sobrecambio debido a las redes densas.
El método de negociación en red controla los riesgos de manera efectiva. Se puede obtener ganancia siempre que los precios fluctúen dentro de la red.
No hay suposición de dirección del precio, adecuado para el mercado de rango limitado.
Las operaciones de negociación en el mercado de divisas se clasifican como operaciones de negociación en el mercado de divisas.
La visualización de las líneas de la red ayuda a comprender la situación comercial.
Los riesgos de ruptura de los precios.
Los riesgos de exceso de espacio de red. Las redes demasiado sueltas no pueden obtener beneficios fácilmente mientras que las demasiado estrechas aumentan los costos. Se necesita equilibrio.
Los riesgos de tenencia prolongada.
Los riesgos derivados de la configuración incorrecta de los parámetros: el período de prueba posterior o el período de media móvil pueden afectar al cálculo del rango de la red si se establece de forma incorrecta.
Riesgos sistémicos de mercado: más adecuados para mercados de tendencia de rango que de largo plazo.
Optimizar los parámetros de la red. Considerar de manera integral las condiciones del mercado, los costos, etc. para optimizar el número de redes, el período de revisión, etc.
Introducir el ajuste dinámico del rango de la red. Adaptar los rangos de la red cuando se produzcan cambios significativos en el mercado.
Incorporar mecanismos de stop loss. Establecer líneas de stop loss adecuadas para limitar las pérdidas. Se puede ajustar dinámicamente.
Añadir filtros que utilizan otros indicadores, como bandas de Bollinger, indicadores de tendencia, etc. para evitar operaciones inadecuadas.
Mejorar la eficiencia del uso del capital, introducir el análisis de volatilidad para reducir las operaciones durante períodos constantes.
La estrategia realiza el comercio de rango controlado por el riesgo mediante el aprovechamiento de los principios de comercio de red. El cálculo automático de la red y la distribución uniforme ofrecen ventajas que se adaptan a varios mercados a través del ajuste de parámetros. Los riesgos son limitados y fáciles de operar. Sin embargo, existen limitaciones y se necesitan mejoras continuas para adaptarse a los mercados en evolución. En general, la estrategia proporciona un enfoque estandarizado y paramétrico para implementar el comercio de red.
/*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)