Diese Strategie nutzt die Netzhandelsmethode in der Ozeantheorie, um Kauf- und Verkaufsbestellungen innerhalb einer vorgegebenen Preisspanne zu platzieren.
Die Strategie berechnet zunächst die oberen und unteren Grenzen des Preisgitters auf der Grundlage der Wahl des Benutzers oder der Standard-Einstellungen. Es gibt zwei Berechnungsmethoden: Erhalten der höchsten und niedrigsten Preise in der Backtesting-Periode oder Berechnung gleitender Durchschnitte über einen Zeitrahmen. Dann werden die Gitterlinien gleichmäßig nach der Anzahl der von dem Benutzer festgelegten Gitter verteilt.
Die Handelssignale werden auf der Grundlage der Beziehung zwischen Preis und Gitterlinien generiert. Wenn der Preis unter einer Gitterlinie liegt, wird eine Long-Position zum Gitterliniepreis mit fester Menge eröffnet; wenn der Preis über eine Gitterlinie geht, wird die Position an der Gitterlinie darunter geschlossen. Da der Preis innerhalb des Gitterwerks schwankt, ändern sich die Positionen entsprechend, um Gewinn zu erzielen.
Insbesondere unterhält die Strategie ein Gitterlinie-Preis-Array und ein Bool-Array, das anzeigt, ob Aufträge an jeder Linie platziert werden. Wenn der Preis unter einer Linie ohne Aufträge liegt, wird eine Long-Position an der Linie geöffnet; wenn der Preis über einer Linie liegt, während Aufträge an der Linie unten vorhanden sind, werden Positionen an der unteren Linie geschlossen.
Die Berechnung des Gitterbereichs erfolgt automatisch, wodurch die manuelle Einstellung unkompliziert erfolgt.
Grid-Linien sind gleichmäßig verteilt, um eine Überlastung durch dichte Gitter zu vermeiden.
Die Grid-Handelsmethode kontrolliert die Risiken effektiv. Gewinn kann erzielt werden, solange der Preis im Netz schwankt.
Keine Annahme der Kursrichtung, geeignet für einen Bereichsmarkt.
Anpassungsfähige Provisions- und Positionsgrößen für verschiedene Handelsinstrumente.
Die Visualisierung von Rasterlinien hilft, die Handelssituation zu verstehen.
Das Überschreiten der oberen oder unteren Netzgrenzen kann zu größeren Verlusten führen.
Übermäßige Netzflächenrisiken. Zu lose Netze können nicht leicht profitieren, während zu enge Netze die Kosten erhöhen.
Langfristige Beteiligungen erschweren den Gewinn und erhöhen die Kosten.
Unzulässige Parameter-Einstellungsrisiken: Eine falsche Einstellung der Backtestperiode oder der gleitenden Durchschnittsperiode kann die Berechnung des Netzbereichs beeinträchtigen.
Systemische Marktrisiken: Mehr geeignet für Bereichsgebundene als für langfristige Trendmärkte.
Optimieren Sie die Netzparameter. Berücksichtigen Sie umfassend die Marktbedingungen, Kosten usw. zur Optimierung der Anzahl der Netze, der Rückblicksperiode usw.
Einführung dynamischer Anpassung des Netzbereichs und Anpassung des Netzbereichs bei erheblichen Marktänderungen.
Einbeziehung von Stop-Loss-Mechanismen, richtige Stop-Loss-Linien zur Begrenzung von Verlusten und dynamische Anpassung.
Fügen Sie Filter hinzu, die andere Indikatoren verwenden, wie Bollinger-Bänder, Trendindikatoren usw., um einen unsachgemäßen Handel zu vermeiden.
Verbesserung der Effizienz der Kapitalnutzung, Einführung von Volatilitätsanalysen zur Verringerung des Handels in regelmäßigen Perioden.
Die Strategie realisiert den risikokontrollierbaren Range-Trading durch Nutzung der Grid-Trading-Prinzipien. Die automatische Grid-Berechnung und die einheitliche Verteilung bieten Vorteile, die verschiedenen Märkten durch Parameter-Tuning entsprechen. Die Risiken sind begrenzt und einfach zu bedienen. Es gibt jedoch Einschränkungen und kontinuierliche Verbesserungen sind erforderlich, um sich an sich entwickelnde Märkte anzupassen. Insgesamt bietet die Strategie einen standardisierten und parametrischen Ansatz zur Umsetzung des Grid-Tradings.
/*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)