Ocean Theory Grid-Handelsstrategie
ChaoZhang
Überblick
Die Strategie verwendet die Grid-Trading-Methode der Meerestheorie, um innerhalb eines festgelegten Preisbereichs eine gleichmäßig verteilte Grid-Linie zu erstellen, um nach der Beziehung zwischen Preis und Grid-Linie zu kaufen und zu verkaufen. Die Strategie verfügt über die Eigenschaften der automatischen Berechnung der Grid-Preisbereiche und der gleichmäßig verteilten Grid-Linie, um das Risiko effektiv zu kontrollieren.
Strategieprinzip
Die Strategie berechnet zunächst die oberen und unteren Grenzen des Preisgitters, die der Benutzer auswählt oder standardmäßig eingestellt hat, d. h. den höchsten und den niedrigsten Preis des Gitters. Es gibt zwei Arten der Berechnung, nämlich die Suche nach den höchsten und niedrigsten Preisen innerhalb eines Rückmesszyklus und die Berechnung des Mittelwerts für einen bestimmten Zeitraum.
Die Erzeugung des Handelssignals hängt von der Beziehung zwischen dem Preis und der Gitterlinie ab. Wenn der Preis unterhalb der unteren Gitterlinie liegt, wird an dieser Gitterlinie eine feste Anzahl von Positionen aufgenommen. Wenn der Preis über der oberen Gitterlinie liegt, wird an dieser Gitterlinie eine feste Anzahl von Positionen abgeschlossen.
Konkret ist die Strategie, ein Grid-Line-Preis-Array und ein Bool-Array zu pflegen, die angeben, ob jede Grid-Linie eine Aufschlüsselung hat. Wenn der Preis unter einer bestimmten Grid-Linie liegt und diese keine Aufschlüsselung hat, wird der Preis auf dieser Linie erhöht.
Strategische Vorteile
Die automatische Berechnung des Rasterbereichs vermeidet die Schwierigkeit der manuellen Einstellung. Es gibt verschiedene Berechnungsmethoden.
Gleichmäßige Verteilung der Gitterlinien, um zu verhindern, dass die Gitterdichte zu übermäßigen Transaktionen führt. Die Anzahl der Gitterlinien kann eingestellt werden.
Die Grid-Trading-Methode ermöglicht eine effektive Risikokontrolle, während Preisschwankungen innerhalb des Grids immer profitabel sind.
Der Preis ist nicht richtungsorientiert und gilt für Szenarien, in denen es zu Schwankungen kommt.
Die Handhabungsgebühren und die Anzahl der Positionen können für verschiedene Handelsarten individuell eingestellt werden.
Die Grid-Linien werden visuell dargestellt, um die Transaktionen zu erfassen.
Strategisches Risiko
Risiko, dass der Preis die unteren Grenzen des Netzes überschreitet, was zu einer Vergrößerung der Verluste führt.
Zu breit ist nicht rentabel, aber zu eng erhöht die Gebühren. Es muss eine Waage getroffen werden.
Das Risiko einer zu langen Haltedauer.
Risiken durch falsche Parameter-Einstellungen. Fehle Parameter-Einstellungen wie Rückmess- oder Durchschnitts-Perioden beeinträchtigen die Berechnung des Rasterintervalls.
Systematische Risiken am Markt. Diese Strategie ist eher für ein turbulentes Umfeld geeignet als für eine langfristige Einseitigkeit.
Strategieoptimierung
Optimieren Sie die Grid-Parameter-Einstellung. Berücksichtigen Sie alle Faktoren wie Marktbedingungen, Transaktionskosten, optimieren Sie die Grid-Anzahl und die Rückmessphase.
Dynamische Anpassung der Gitterräume. Bei größeren Marktveränderungen kann ein Mechanismus zur dynamischen Anpassung der Gitterräume eingeführt werden.
Einstieg in die Stop-Loss-Mechanismen. Setzen Sie eine angemessene Stop-Line, um zu große Verluste zu vermeiden. Die Stop-Line kann auch dynamisch angepasst werden.
In Kombination mit anderen Indikatoren Filterhandel. Wie Brinline, Trend Indicator, etc., um unpassende Handel zu vermeiden.
Optimierung der Kapitalnutzungs-Effizienz. Einschaltung von Kalte-Heat-Analysen, reduzieren Sie die Transaktionen bei geringerer Volatilität.
Zusammenfassen
Die Strategie nutzt die Grid-Trading-Prinzipien, um einen riskbeherrschbaren, wackligen Handel zu realisieren. Die Strategie hat die Vorteile eines automatisch berechneten Grids, eines gleichmäßig verteilten Grids und kann an verschiedene Marktumgebungen angepasst werden, indem die Parameter angepasst werden. Die Risiken sind kontrollierbar und einfach zu bedienen. Die Strategie hat jedoch auch einige Grenzen, die kontinuierlich optimiert werden müssen, um sich an Marktveränderungen anzupassen.
/*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)