Dynamische Netzhandelsstrategie

Schriftsteller:ChaoZhang, Datum: 2024-01-23 10:53:05
Tags:

Übersicht

Diese Strategie implementiert den Netthandel, indem mehrere parallele Kauf- und Verkaufsaufträge innerhalb einer Preisspanne platziert werden.

Strategie Logik

Festlegen der oberen und unteren Grenzen des Netzes, die manuell konfiguriert oder automatisch berechnet werden können, basierend auf den jüngsten Hoch- und Tiefpreisen.
Berechnen Sie die Breite des Gitterintervalls entsprechend der angegebenen Anzahl von Gitterlinien.
Erzeugen Sie ein Netzliniepreisarray mit entsprechender Menge.
Wenn der Preis unter eine Gitterlinie fällt, öffnen Sie eine Long-Order darunter; wenn der Preis über eine Gitterlinie steigt, schließen Sie eine Short-Order darüber.
Dynamische Anpassung der Grenzen, der Intervallbreite und der Stromnetzpreise, um die Strategie an die Marktveränderungen anzupassen.

Analyse der Vorteile

Kann unabhängig von der Trendrichtung in einem volatilen Markt stetig profitieren.
Unterstützt sowohl manuelle als auch automatische Parameter Einstellungen für eine hohe Anpassungsfähigkeit.
Optimierbare Parameter wie Gittermenge, Intervallbreite und Bestellgröße für eine bessere Belohnung.
Eingebettete Positionssteuerung für geringeres Risiko.
Die dynamische Anpassung des Netzbereichs erhöht die Anpassungsfähigkeit.

Risikoanalyse

Bei starken Markttrends kann es zu starken Verlusten kommen.
Eine falsche Einstellung der Netzmenge und Position kann das Risiko verstärken.
Der automatisch berechnete Netzbereich kann bei extremen Preisschwankungen fehlschlagen.

Risikomanagement:

Optimieren Sie die Gitterparameter und kontrollieren Sie die Gesamtposition.
Schließen Sie die Strategie, bevor sich der Preis erheblich bewegt.
Beurteilen Sie die Marktlage anhand von Trendindikatoren, schließen Sie bei Bedarf eine Strategie ab.

Optimierungsrichtlinien

Auswahl der optimalen Netzmenge anhand des Marktcharakters und des Kapitalumfangs.
Verschiedene Perioden testen, um die Parameter zu optimieren.
Optimieren Sie die Berechnung der Auftragsgröße für eine stabilere Belohnung.
Hinzufügen von Indikatoren für die Tendenzbestimmung und Strategie-Schließbedingungen.

Zusammenfassung

Die dynamische Netzhandelsstrategie passt sich dem Markt an, indem sie die Netzparameter anpasst. Sie profitiert im Bereich und volatilen Markt. Mit einer ordnungsgemäßen Positionskontrolle wird das Risiko gemindert. Die Optimierung der Netz-Einstellungen und die Einbeziehung von Trendbeurteilungsindikatoren können die Stabilität der Strategie weiter verbessern.

/*backtest
start: 2023-12-23 00:00:00
end: 2024-01-22 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("sarasa srinivasa kumar", 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="(Auto) 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="(Auto) 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

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
strategy.initial_capital = 50000
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)

Mehr