Größenblockstrategie

Schriftsteller:ChaoZhang, Datum: 2023-11-06 09:20:34
Tags:

Übersicht

Die Sizeblock-Strategie ist eine Handelsstrategie, die auf der Prozentsatz- oder Tick-Abweichung der Preisänderungen basiert, die in diagonalen Zeilen angezeigt werden. Sie kann lokale Trends und Umkehrpunkte auf dem Diagramm deutlich zeigen. Dies ist ein sehr nützliches Werkzeug zur Verfolgung der Kursrichtung.

Grundsätze

Die Berechnung erfolgt anhand der Prozentsatz- oder Tick-Abweichung der Kursbewegung (in dem Parameter Abweichung angegeben), die im Diagramm in Zeilen dargestellt wird.

Die Zeile besteht aus der mittleren Grundlinie, den oberen und unteren Grenzen:

Die Basismittellinie ist gleich den oberen oder unteren Grenzen der vorherigen Zeile (wenn sich der Preis in einem Zeitintervall rasch ändert, dann ist die Basismittellinie der aktuellen Zeile größer als die obere Grenze der vorherigen Zeile oder kleiner als die untere Grenze der vorherigen Zeile um eine gleiche Anzahl von Abweichungen je nach Kursbewegung).
Der Parameter Quantity bestimmt die Abweichung für die oberen oder unteren Grenzen je nach Kursrichtung, und der Parameter U-turn bestimmt die Abweichung für die Änderung der Kursrichtung.

Die Regel für den Aufbau einer neuen Zeile:

Wenn die Schließung ≥ die Obergrenze und die Schließung > offen ist, wird sich die Obergrenze allmählich nach oben bewegen, und die untere Grenze wird sich ebenfalls nach oben bewegen, aber weniger.
Wenn die niedrigste Grenze ≤ die untere Grenze und die schließende < offen ist, wird sich die untere Grenze allmählich nach unten bewegen, und die obere Grenze wird sich ebenfalls nach unten bewegen, aber weniger.

Durch die Anpassung bestimmter Abweichungen können Sie den lokalen Trend und die Umkehrpunkte auf dem Diagramm deutlich sehen.

Vorteile

Sichtbar machen, wie sich die Preisschwankungen entwickeln, und deutlich Unterstützung und Widerstand erkennen.
Die diagonalen Linien zeigen deutlich die Stärke der Ausbrüche und den Bereich der Rückzüge.
Die Neigung der diagonalen Linien kann je nach Bedarf angepasst werden, um Trends unterschiedlicher Stärke zu erkennen.
Kann relativ große Unterstützung und Widerstand für Ausbrüche finden.
Es ist leicht, Veränderungen des Kursrhythmus zu erkennen und die Positionsgröße entsprechend anzupassen.

Risiken

Diagonale Linien können nachfolgende Kursbewegungen nicht vollständig genau vorhersagen.
Es müssen Trends beobachtet werden, bei denen die diagonalen Linien von den tatsächlichen Preisen abweichen können.
Es kann nicht als isolierte Strategie verwendet werden, es müssen andere Indikatoren einbezogen werden, um den Haupttrend zu bestimmen.
Unzulässige Anpassungen von Parametern können zu einem zu häufigen Handel führen.
Man muss sich vor möglichen Umkehrungen während der Rückgänge hüten, anstatt blind nach Trends zu jagen.

Kann die Positionsgröße mäßig reduzieren und sich auf andere Indikatoren als Hilfsbeurteilung innerhalb der wichtigsten Trends beziehen.

Optimierung

Kann Positionsmanagementmodule hinzufügen, um Positionen in verschiedenen Trendstadien dynamisch anzupassen.
Kann Volatilitätsindikatoren enthalten, um Positionen bei steigender Volatilität zu reduzieren.
Kann Stop Loss basierend auf dem Zugriffsprozentsatz einstellen, um Einzelverluste zu kontrollieren.
Kann Filter hinzufügen, um den Handel zu pausieren, wenn Preisunterschiede auftreten.
Kann diagonale Neigungen in mehrere Ebenen aufteilen, um Trendänderungen unterschiedlicher Stärke zu erkennen.

Durch die dynamische Anpassung von Positionen, das Setzen von Stops und Filtern können Kursentwicklungen stabiler verfolgt werden.

Zusammenfassung

Die Sizeblock-Strategie nutzt diagonale Linien, um Preistrendveränderungen intuitiv darzustellen und Support-, Widerstands- und Breakout-Levels klar zu identifizieren. Aber sie kann sich nicht ausschließlich auf diagonale Linien für das Urteilen verlassen, sondern muss Analysen aus anderen Indikatoren einbeziehen und Risiken verwalten. Dies ist ein sehr wertvolles Hilfswerkzeug, um den Händlern zu helfen, den Marktrhythmus besser zu verstehen. Optimierung kann die Strategie robuster und effizienter mit großem Anwendungspotenzial machen.

/*backtest
start: 2023-10-06 00:00:00
end: 2023-11-05 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
// **********************************************************************************
// This code is invented and written by @StCogitans.
// The idea presented in this code and the rights to this code belong to @StCogitans.
// © https://www.tradingview.com/u/StCogitans
//
// Description.
// Sizeblock - a price change strategy in the form of diagonal rows.
// **********************************************************************************

// STRATEGY
string NAME        = 'Sizeblock'
string ACRONYM     = 'SB'
bool OVERLAY       = true
int PYRAMIDING     = 0
string QTY_TYPE    = strategy.percent_of_equity
float QTY_VALUE    = 100
float CAPITAL      = 100
string COM_TYPE    = strategy.commission.percent
float COM_VALUE    = 0.1
bool ON_CLOSE      = false
bool BAR_MAGNIFIER = false
bool OHLC          = true
strategy(NAME, ACRONYM, OVERLAY, pyramiding=PYRAMIDING, default_qty_type=QTY_TYPE, default_qty_value=QTY_VALUE, initial_capital=CAPITAL, commission_type=COM_TYPE, commission_value=COM_VALUE, process_orders_on_close=ON_CLOSE, use_bar_magnifier=BAR_MAGNIFIER, fill_orders_on_standard_ohlc=OHLC)

// ARGUMENTS
// Datetime
DTstart  = input(timestamp("01 Jan 2000 00:00 +0000"), 'Start time', group='Datetime')
DTfinish = input(timestamp("01 Jan 2080 23:59 +0000"), 'Finish time', group='Datetime')
DTperiod = true

// Main
dev_source = input.string('Close', title='Source', options=["Close", "HighLow"], tooltip='Price data for settlement.', group='Main')
dev_type   = input.string('Percentage', title='Deviation', options=['Percentage', 'Ticks'], tooltip='The type of deviation to calculate.', group='Main')
dev_value  = input.float(1, title='Quantity', minval=0.001, step=0.01, tooltip='Quantity to be calculated.', group='Main')
dev_back   = input.float(2, title='U-turn', minval=0.001, step=0.01, tooltip='Quantity for reversal.', group='Main')
mode       = input.string('Limit', title='Positions', options=['Limit', 'Market'], tooltip='Limit or market orders.', group='Main')
direct     = input.string('All', title='Direction', options=['All', 'Buy', 'Sell'], tooltip='The type of positions to be opened.', group='Main')
swapping   = input.bool(false, title='Swapping', tooltip='Swap points to open a new position.', group='Main')

// CALCULATION SYSTEM
Assembling(s, t, v, vb) =>

    float a = open
    float b = close
    float c = s == "HighLow" ? math.round_to_mintick(high) : math.round_to_mintick(b)
    float d = s == "HighLow" ? math.round_to_mintick(low) : math.round_to_mintick(b)

    float x = math.round_to_mintick(a)
    x := nz(x[1], x)

    float _v = t == "Ticks" ? syminfo.mintick * v : v
    float _vb = t == "Ticks" ? syminfo.mintick * vb : vb

    float h = t == "Ticks" ? math.round_to_mintick(x + _v) : math.round_to_mintick(x * (1 + _v / 100))
    float l = t == "Ticks" ? math.round_to_mintick(x - _v) : math.round_to_mintick(x * (1 - _v / 100))
    h := nz(h[1], h)
    l := nz(l[1], l)

    if t == "Ticks"
    
        if c >= h and b > a
            while c >= h
            
                x := h
                h := math.round_to_mintick(h + _v)
                l := math.round_to_mintick(x - _vb)
        
        if d <= l and b < a
            while d <= l
            
                x := l
                l := math.round_to_mintick(l - _v)
                h := math.round_to_mintick(x + _vb)

    else if t == "Percentage"
    
        if c >= h and b > a
            while c >= h
        
                x := h
                h := math.round_to_mintick(h * (1 + _v / 100))
                l := math.round_to_mintick(x * (1 - _vb / 100))

        if d <= l and b < a
            while d <= l
        
                x := l
                l := math.round_to_mintick(l * (1 - _v / 100))
                h := math.round_to_mintick(x * (1 + _vb / 100))

    [x, h, l]

[lx, lh, ll] = Assembling(dev_source, dev_type, dev_value, dev_back)

// PLOT
// Lines
plot_up   = plot(lh, color=color.new(color.green, 50), style=plot.style_line, linewidth=1)
plot_main = plot(lx, color=color.new(color.silver, 50), style=plot.style_line, linewidth=1)
plot_down = plot(ll, color=color.new(color.red, 50), style=plot.style_line, linewidth=1)

// Areas
fill(plot_up, plot_main, lh, lx, color.new(color.teal, 80), color.new(color.teal, 80))
fill(plot_main, plot_down, lx, ll, color.new(color.maroon, 80), color.new(color.maroon, 80))

// TRADING
// Alert variables
int Action = -1
int PosType = -1
int OrderType = -1
float Price = -1.0

// Direction variables
bool ifBuy = direct == "All" or direct == "Buy" ? true : false
bool ifSell = direct == "All" or direct == "Sell" ? true : false

// Market entries
if (strategy.closedtrades + strategy.opentrades == 0 or mode == "Market") and DTperiod
    if ((swapping and lx < nz(lx[1], lx)) or (not swapping and lx > nz(lx[1], lx))) and ifBuy
        Action := 1
        PosType := 1
        OrderType := 1
        Price := math.round_to_mintick(close)
        strategy.entry('Long', strategy.long)
    if ((swapping and lx > nz(lx[1], lx)) or (not swapping and lx < nz(lx[1], lx))) and ifSell
        Action := 2
        PosType := 2
        OrderType := 1
        Price := math.round_to_mintick(close)
        strategy.entry('Short', strategy.short)

// Closing positions by market
if DTperiod and mode == "Market"
    if direct == "Buy" and strategy.position_size > 0
        if swapping and lx > nz(lx[1], lx)
            Action := 2
            PosType := 3
            OrderType := 1
            Price := math.round_to_mintick(close)
            strategy.close('Long', comment='Close')
        if not swapping and lx < nz(lx[1], lx)
            Action := 2
            PosType := 3
            OrderType := 1
            Price := math.round_to_mintick(close)
            strategy.close('Long', comment='Close')
    if direct == "Sell" and strategy.position_size < 0
        if swapping and lx < nz(lx[1], lx)
            Action := 1
            PosType := 3
            OrderType := 1
            Price := math.round_to_mintick(close)
            strategy.close('Short', comment='Close')
        if not swapping and lx > nz(lx[1], lx)
            Action := 1
            PosType := 3
            OrderType := 1
            Price := math.round_to_mintick(close)
            strategy.close('Short', comment='Close')

// Limit entries and exits
if swapping and DTperiod and mode == "Limit"
    if strategy.position_size < 0
        Action := 1
        PosType := 1
        OrderType := 2
        Price := ll
        if ifBuy
            strategy.entry('Long', strategy.long, limit=ll)
        else
            PosType := 3
            strategy.exit('Exit', limit=ll)
    if strategy.position_size > 0
        Action := 2
        PosType := 2
        OrderType := 2
        Price := lh
        if ifSell
            strategy.entry('Short', strategy.short, limit=lh)
        else
            PosType := 3
            strategy.exit('Exit', limit=lh)
    if strategy.closedtrades + strategy.opentrades > 0 and strategy.position_size == 0
        if ifBuy
            Action := 1
            PosType := 1
            OrderType := 2
            Price := ll
            strategy.entry('Long', strategy.long, limit=ll)
        if ifSell
            Action := 2
            PosType := 2
            OrderType := 2
            Price := lh
            strategy.entry('Short', strategy.short, limit=lh)
if not swapping and DTperiod and mode == "Limit"
    if strategy.position_size < 0
        Action := 1
        PosType := 1
        OrderType := 2
        Price := lh
        if ifBuy
            strategy.entry('Long', strategy.long, stop=lh)
        else
            PosType := 3
            strategy.exit('Exit', stop=lh)
    if strategy.position_size > 0
        Action := 2
        PosType := 2
        OrderType := 2
        Price := ll
        if ifSell
            strategy.entry('Short', strategy.short, stop=ll)
        else
            PosType := 3
            strategy.exit('Exit', stop=ll)
    if strategy.closedtrades + strategy.opentrades > 0 and strategy.position_size == 0
        if ifBuy
            Action := 1
            PosType := 1
            OrderType := 2
            Price := lh
            strategy.entry('Long', strategy.long, stop=lh)
        if ifSell
            Action := 2
            PosType := 2
            OrderType := 2
            Price := ll
            strategy.entry('Short', strategy.short, stop=ll)

// Everything is closed and canceled
if not DTperiod
    strategy.cancel_all()
    strategy.close_all(comment='Close')

// Alerts
// Convert to string variables
string Action_Txt = Action == 1 ? "Buy" : Action == 2 ? "Sell" : na
string PosType_Txt = PosType == 1 ? "Long" : PosType == 2 ? "Short" : PosType == 3 ? "Flat" : na
string OrderType_Txt = OrderType == 1 ? "Market" : OrderType == 2 ? "Limit" : na
string Price_Txt = Price > 0 ? str.tostring(Price) : na

// Output
if not (Action == nz(Action[1], Action) and Price == nz(Price[1], Price) and OrderType == nz(OrderType[1], OrderType)) and DTperiod
    alert('{"pair": "' + syminfo.ticker + '", "direction": "' + Action_Txt + '", "entertype": "' + OrderType_Txt + '", "position": "' + PosType_Txt + '", "price": "' + Price_Txt + '"}')

// *********************
// Good job, Soldier! ;>
// *********************

Mehr