Die Ressourcen sind geladen. Beförderung...

Grid-basierte Long Martingale Dynamic Position Grid-Handelsstrategie

Schriftsteller:ChaoZhang, Datum: 2024-03-22 15:12:33
Tags:

img

Strategieübersicht

Diese Strategie ist eine rasterbasierte lange Martingale-dynamische Positions-Grid-Handelsstrategie. Die Hauptidee besteht darin, die Positionsgröße dynamisch anhand der Anzahl der vorhandenen Positionen anzupassen, wenn der Preis die Rasterlinien erreicht, während eine maximale Gesamtzahl offener Positionen festgelegt wird. Wenn der Preis steigt und das Take-Profit-Level erreicht, werden alle Long-Positionen geschlossen.

Strategieprinzipien

  1. Teilen Sie den Preis in gleichmäßig verteilte Gitter auf der Grundlage des Parameters Grid Size.
  2. Lange Grenzbefehle an jeder Rasterlinie.
  3. Wenn der aktuelle Preis eine Gitterlinie erreicht:
    • Wenn die aktuelle Anzahl offener Positionen 0 beträgt, öffnen Sie eine Position mit der Größe start_lot.
    • Wenn die aktuelle Anzahl der offenen Positionen größer als 0 ist und der aktuelle Netznutzungspreis niedriger ist als der vorherige Einstiegspreis, wird eine neue Longposition zum aktuellen Netznutzungspreis mit einer Größe eröffnet, die multifaktor mal die vorherige Positionsgröße beträgt.
  4. Die maximale Anzahl offener Positionen wird durch den Parameter Max Open Orders geregelt.
  5. Nach Eröffnung einer Position wird ein Take-Profit-Level auf TakeProfit Punkte über dem durchschnittlichen Einstiegspreis gesetzt.
  6. Wenn der aktuelle Preis die Gewinnspanne erreicht, schließen Sie alle Long-Positionen und setzen Sie die Parameter zurück.

Auf diese Weise steigt die Positionsgröße während der Abwärtstrends allmählich an, und Gewinne werden erzielt, wenn sich der Preis erholt und die Gewinnspanne erreicht.

Strategische Vorteile

  1. Dynamische Positionsgröße: Dynamische Anpassung der Positionsgröße für jeden Eintrag basierend auf der aktuellen Anzahl offener Positionen. Dies erhöht die Exposition während anhaltender Abwärtstrends allmählich und erhöht das Gewinnpotenzial der Strategie.
  2. Flexible Parameter: Die Grid Size, start_lot, multifactor und andere Parameter ermöglichen eine flexible Steuerung der Gridgröße, der Anfangsposition, des Positionsskalierfaktors usw.
  3. Kontrollierbares Risiko: Der Parameter Max Open Orders steuert die maximale Anzahl offener Positionen, um eine Überbelastung zu vermeiden.

Strategische Risiken

  1. Keine Stop-Loss: Die Strategie hat keine Stop-Losses.
  2. Parameterempfindlichkeit: Die Leistung der Strategie ist sehr empfindlich gegenüber Parametern wie "Multifaktor".
  3. Hohe Volatilität: Die Strategie kann bei sehr volatilen Marktbedingungen häufig Positionen eröffnen und schließen, was möglicherweise zusätzliche Verschiebungskosten und Provisionskosten zur Folge hat.

Risikokontrollmaßnahmen:

  1. Vorsichtig Parameter wie multifactor basierend auf der Risikotoleranz festlegen.
  2. Sie werden sorgfältig zurückgetestet, um geeignete Parameter auszuwählen.
  3. Beurteilen Sie die Leistung der Strategie unter stark volatilen Marktbedingungen.

Optimierungsrichtlinien

  1. Hinzufügen von Trenddetektion: Beurteilen Sie den Trend anhand der Kursbewegung bei der Eröffnung von Positionen.
  2. Dynamische Gewinnspanne: Dynamische Anpassung der Gewinnspanne anhand von Kursentwicklung, Volatilität und anderen Indikatoren.
  3. Optimierung der Positionsverwaltung: Bei der Erhöhung der Positionen ist neben der Berücksichtigung des Skalierungsfaktors auch der Kontostand, das aktuelle Risiko usw. zu berücksichtigen, um die Positionsgröße genauer zu steuern.
  4. Kombination mit anderen Signalen: Integration des Netthandels mit anderen Trenddetektionen, Schwingungsdetektionen und anderen Indikatorsignalen, um den Markt umfassend zu beurteilen und den Handel zu leiten.

Diese Optimierungen können die Anpassungsfähigkeit der Strategie verbessern, um Marktbewegungen besser zu erfassen, das Gewinnpotenzial und die Robustheit zu erhöhen.

Zusammenfassung

Diese rasterbasierte lange Martingale-dynamische Positions-Grid-Handelsstrategie versucht, den durchschnittlichen Haltpreis während Abwärtstrends zu senken, indem sie Positionen allmählich hinzufügt und Gewinne erzielt, wenn die Preise steigen. Die Strategie bietet durch Parameter-Einstellungen eine starke Flexibilität. Sie birgt jedoch auch erhebliche potenzielle Risiken, die eine sorgfältige Bewertung und Kontrolle erfordern. Wenn Trenderkennung, dynamischer Gewinn, Positionsoptimierung und andere Funktionen hinzugefügt werden können, kann die Leistung der Strategie weiter verbessert werden. Die Strategie realisiert Funktionen, um automatisch zu öffnen und Positionen hinzuzufügen, wenn die Preise die Rasterlinien erreichen, und automatisch alle Positionen zu schließen, wenn die Preise das Gewinnniveau erreichen. Die Gesamtlogik ist relativ klar, aber es gibt Raum für Optimierung.


/*backtest
start: 2023-03-16 00:00:00
end: 2024-03-21 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © lagerta13
//@version=4
strategy("Grid A.", shorttitle="Grid(A)", overlay=true, format=format.price, precision=4, pyramiding = 100)

input_tf=input("15", "Started TimeFrame", 
 options = ["1", "5", "15", "30", "1H", "4H", "1D", "1W", "1M"],
 group="TimeFrame") 

// avg_tf=input("5", "Average TimeFrame", 
//  options = ["1", "5", "15", "30", "1H", "4H", "1D", "1W", "1M"],
//  group="TimeFrame")

slip_Hilo = input(3.0, "Slippage by open order", group="Strategy Settings")
start_lot = input(0.01, "Start lot", group="Strategy Settings")
start_avg = input(2, "Started average since Order #", group="Strategy Settings")
MaxTrades_Hilo = input(10, "Max Open Orders", group="Strategy Settings")
dropdown_selection = input("Only Long", "Direction", options=["Only Long", "Only Short", "Long & Short"],
 group="Strategy Settings")
type_selection = input("By Close", "Type input", options=["By Close", "By grid line"],
 group="Strategy Settings")

multifactor = input(1.5, "Multifactor", group="Strategy Settings")
precision_lot = input(2, "Number of precision", group="Strategy Settings")
take_profit = input(1, "TakeProfit", group="Strategy Settings")

// PipStep_S1 = input(30)
// PipStepX_S1 = input(1.2)
// dinamicStep = input(false, "Dinamic Step for AVG")

get_size_lot_order(number, multi, prec, avg_from, lot_from) =>
	res = lot_from
	for i = 1 to number
		if i >= avg_from
			res := round(res * multi, precision = prec)
	res

var float[] entry_levels = array.new_float(MaxTrades_Hilo + 1)

for i = 0 to MaxTrades_Hilo
    array.push(entry_levels, 0)

gridSize = input(0.5, title="Grid Size")
gridLevels = int(close / gridSize) * gridSize

var int num_open_orders = 0
var float sum_price_orders = 0
var float entry_lot = 0

buy_condition = num_open_orders < MaxTrades_Hilo and gridLevels[0]<gridLevels[1] and dropdown_selection != "Only Short"

if (buy_condition)

    if num_open_orders == 0
        lot = get_size_lot_order(num_open_orders, multifactor, precision_lot, start_avg, start_lot)
        sum_price_orders := sum_price_orders + gridLevels[1] * lot 

        strategy.entry("buy" + tostring(num_open_orders), true, qty=lot, limit=gridLevels[1]+slip_Hilo) 
        // strategy.order("buy" + tostring(num_open_orders), true, qty=lot, limit=gridLevels[1]) 

        array.set(entry_levels, num_open_orders, gridLevels[1])

        entry_lot := entry_lot + lot
        num_open_orders := num_open_orders + 1

    else
        if gridLevels[1] < (array.get(entry_levels, num_open_orders - 1))
            lot = get_size_lot_order(num_open_orders, multifactor, precision_lot, start_avg, start_lot)
            sum_price_orders := sum_price_orders + gridLevels[1] * lot 
            entry_lot := entry_lot + lot

            strategy.entry("buy" + tostring(num_open_orders), true, qty=lot, limit=gridLevels[1]+slip_Hilo) 

            // +" S:" + tostring(sum_price_orders / (entry_lot)) + " Prev:" + tostring(array.get(entry_levels, num_open_orders - 1))
            // strategy.order("buy" + tostring(num_open_orders), true, qty=lot, limit=gridLevels[1]) 
            array.set(entry_levels, num_open_orders, gridLevels[1])

            num_open_orders := num_open_orders + 1


take = sum_price_orders > 0 and take_profit + (sum_price_orders / entry_lot) < high ? high : na
plotshape(take, location = location.belowbar, color = color.white)


strategy.exit("tp", comment = "TP " + tostring(num_open_orders), qty = entry_lot, limit = take_profit + (sum_price_orders / entry_lot))


if sum_price_orders > 0 and take_profit + (sum_price_orders / entry_lot) <= high
    num_open_orders := 0
    sum_price_orders := 0
    entry_lot := 0
    for i = 0 to MaxTrades_Hilo
        array.set(entry_levels, i, 0)

plot(gridLevels, color=color.blue, style=plot.style_circles, linewidth=2)

 

Mehr