Strategie zur Umkehrung des ruhenden Bereichs

Schriftsteller:ChaoZhang, Datum: 2023-10-30 10:54:00
Tags:

Übersicht

Die Strategie zur Umkehrung des ruhenden Bereichs nutzt Perioden abnehmender Volatilität als Einstiegssignale und zielt darauf ab, zu profitieren, wenn die Volatilität wieder ansteigt. Sie identifiziert Situationen, in denen der Preis innerhalb eines engen ruhenden Bereichs enthalten ist und den bevorstehenden Preistrend erfasst. Diese Strategie funktioniert gut, wenn die aktuelle Volatilität gering ist, aber ein Ausbruch erwartet wird.

Strategie Logik

Die Strategie identifiziert zunächst einen ruhenden Bereich, bei dem der Preis innerhalb des Preisbereichs des vorherigen Handelstages liegt. Dies zeigt an, dass die Volatilität im Vergleich zu vor wenigen Tagen abgenommen hat. Wir überprüfen, ob das aktuelle Tageshoch < das hohe Niveau von n Tagen zuvor (normalerweise 4 Tage) und das aktuelle Tagestief > das niedrige Niveau von n Tagen zuvor als ruhender Bereich gelten.

Sobald eine ruhende Bandbreite identifiziert wurde, platziert die Strategie zwei ausstehende Aufträge - einen Buy-Stop nahe der Oberseite der Bandbreite und einen Sell-Stop nahe der Unterseite der Bandbreite. Sie wartet dann darauf, dass der Preis entweder nach oben oder nach unten aus der Bandbreite ausbricht. Wenn der Preis nach oben bricht, wird die Buy-Order ausgelöst, um lang zu gehen. Wenn der Preis nach unten bricht, wird die Sell-Order ausgelöst, um kurz zu gehen.

Nach dem Eintritt werden Stop-Loss- und Take-Profit-Orders platziert. Der Stop-Loss kontrolliert das Abwärtsrisiko und der Take-Profit schließt den Handel für den Gewinn. Der Stop-Loss wird in einem % Abstand vom Einstiegspreis platziert, wie in den Risikoparametern definiert. Der Take-Profit wird in einem Abstand platziert, der der Schlafbereichsgröße entspricht, da wir erwarten, dass sich der Preis ähnlich der vorherigen Volatilität bewegt.

Schließlich verwaltet ein festes fractionelles Positionsgrößenmodell die Handelsgröße. Es erhöht die Größe für Gewinne und reduziert die Größe für Verluste, um die risikobereinigten Renditen zu verbessern.

Vorteile

Die Vorteile dieser Strategie sind:

Erfasst den bevorstehenden Trend, indem er eine verringerte Volatilität als Signal verwendet.
Die zweiseitigen Aufträge erfassen Aufwärtstrend oder Abwärtstrend.
Stop-Loss- und Take-Profit-Kontrollen für das einzelne Handelsrisiko.
Eine feste Fraktionsgröße verbessert die Kapitalleistung.
Einfache Logik, einfach umzusetzen.

Risiken

Die zu berücksichtigenden Risiken sind:

Falsche Ausbruchrichtung, wenn der Ausbruch in der Reichweite unklar ist.
Ein Ausbruch kann nur eine kurze Umkehrung sein, kein dauerhafter Trend.
Stop-Loss-Risiko, durch große Bewegungen ausgeschaltet zu werden.
Eine feste Fraktionsgröße kann Verluste vergrößern, wenn sie zu verlorenen Trades beiträgt.
Schlechte Leistung, wenn die Parameter nicht richtig eingestellt sind.

Möglichkeiten zur Verbesserung

Einige Möglichkeiten zur Verbesserung der Strategie:

Fügen Sie Filter wie Divergenz hinzu, um falsche Ausbrüche zu vermeiden.
Verbessern Sie den Stop-Loss mit Trailing- oder Order-Stop-Loss.
Hinzufügen eines Trendfilters, um Gegentrend-Einträge zu vermeiden.
Optimieren Sie feste Fraktionsverhältnisse für ein ausgewogenes Risiko/Rendite.
Schauen Sie sich mehrere Zeitrahmen an, um den Rand zu verbessern.
Verwenden Sie maschinelles Lernen für die automatisierte Optimierung von Parametern.

Schlussfolgerung

Die dormante Range-Umkehrstrategie hat eine klare Logik und ein Gewinnpotenzial. Eine Feinabstimmung durch Optimierungen, Risikomanagement und Signalfilterung kann die Konsistenz weiter verbessern. Aber alle mittleren Umkehrstrategien bergen inhärente Risiken und die Positionsgröße muss kontrolliert werden. Sie eignet sich für Trader, die mit Umkehrtaktiken vertraut sind und ein solides Risikobewusstsein besitzen.

/*backtest
start: 2023-09-29 00:00:00
end: 2023-10-29 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/
// © gsanson66


//This code is based on the Narrow Range strategy
//Interactive Broker fees are applied on this strategy
//@version=5
strategy("NARROW RANGE BACKTESTING", shorttitle="NR BACKTESTING", overlay=true, initial_capital=1000, default_qty_type=strategy.fixed, commission_type=strategy.commission.percent, commission_value=0.18)


//--------------------------------FUNCTIONS------------------------------------//

//@function to print label
debugLabel(txt, color) =>
    label.new(bar_index, high, text = txt, color=color, style = label.style_label_lower_right, textcolor = color.black, size = size.small)

//@function which looks if the close date of the current bar falls inside the date range
inBacktestPeriod(start, end) => (time >= start) and (time <= end)


//--------------------------------USER INPUTS------------------------------------//

//Narrow Range Length 
nrLength = input.int(4, minval=2, title="Narrow Range Length", group="Strategy parameters")
//Risk Management
stopLossInput = input.float(0.5, title="Stop Loss (in percentage of reference range)", group="Strategy parameters")
//Money Management
fixedRatio = input.int(defval=400, minval=1, title="Fixed Ratio Value ($)", group="Money Management")
increasingOrderAmount = input.int(defval=200, minval=1, title="Increasing Order Amount ($)", group="Money Management")
//Backtesting period
startDate = input(title="Start Date", defval=timestamp("1 Janv 2020 00:00:00"), group="Backtesting Period")
endDate = input(title="End Date", defval=timestamp("1 July 2024 00:00:00"), group="Backtesting Period")


//--------------------------------VARIABLES INITIALISATION--------------------------//
strategy.initial_capital = 50000
bool nr = na
var bool long = na
var bool short = na
var float stopPriceLong = na
var float stopLossLong = na
var float takeProfitLong = na
var float stopPriceShort = na
var float stopLossShort = na
var float takeProfitShort = na
var float takeProfit = na
var float stopLoss = na
bool inRange = na
int closedtrades = strategy.closedtrades
equity = math.abs(strategy.equity - strategy.openprofit)
var float capital_ref = strategy.initial_capital
var float cashOrder = strategy.initial_capital * 0.95


//------------------------------CHECKING SOME CONDITIONS ON EACH SCRIPT EXECUTION-------------------------------//

//Checking if the date belong to the range
inRange := true

//Checking performances of the strategy
if equity > capital_ref + fixedRatio
    spread = (equity - capital_ref)/fixedRatio
    nb_level = int(spread)
    increasingOrder = nb_level * increasingOrderAmount
    cashOrder := cashOrder + increasingOrder
    capital_ref := capital_ref + nb_level*fixedRatio
if equity < capital_ref - fixedRatio
    spread = (capital_ref - equity)/fixedRatio
    nb_level = int(spread)
    decreasingOrder = nb_level * increasingOrderAmount
    cashOrder := cashOrder - decreasingOrder
    capital_ref := capital_ref - nb_level*fixedRatio

//We check if a trade has been closed to cancel all previous orders
if closedtrades > closedtrades[1]
    strategy.cancel("Long")
    strategy.cancel("Short")
    stopPriceLong := na
    stopPriceShort := na

//Checking if we close all trades in case where we exit the backtesting period
if strategy.position_size!=0 and not inRange
    debugLabel("END OF BACKTESTING PERIOD : we close the trade", color=color.rgb(116, 116, 116))
    strategy.close_all()
    long := na
    short := na
    stopPriceLong := na
    stopLossLong := na
    takeProfitLong := na
    stopPriceShort := na
    stopLossShort := na
    takeProfitShort := na
    takeProfit := na
    stopLoss := na

//----------------------------------FINDING NARROW RANGE DAY------------------------------------------//

// We find the Narrow Range Day
if low > low[nrLength] and high < high[nrLength]
    nr := true 


//------------------------------------STOP ORDERS--------------------------------------------//

// We handle plotting of stop orders and cancellation of other side order if one order is triggered
if strategy.position_size > 0 and not na(stopPriceLong) and not na(stopPriceShort)
    long := true
    strategy.cancel("Short")
    stopPriceLong := na
    stopPriceShort := na
    takeProfit := takeProfitLong
    stopLoss := stopLossLong
if strategy.position_size < 0 and not na(stopPriceLong) and not na(stopPriceShort)
    short := true
    strategy.cancel("Long") 
    stopPriceLong := na
    stopPriceShort := na
    takeProfit := takeProfitShort
    stopLoss := stopLossShort


//------------------------------------STOP LOSS & TAKE PROFIT--------------------------------//

// If an order is triggered we plot TP and SL
if not na(takeProfit) and not na(stopLoss) and long
    if high >= takeProfit and closedtrades == closedtrades[1] + 1
        takeProfit := na
        stopLoss := na
        long := na
    if low <= stopLoss and closedtrades == closedtrades[1] + 1
        takeProfit := na
        stopLoss := na
        long := na
if not na(takeProfit) and not na(stopLoss) and short
    if high >= stopLoss and closedtrades == closedtrades[1] + 1
        takeProfit := na
        stopLoss := na
        short := na
    if low <= takeProfit and closedtrades == closedtrades[1] + 1
        takeProfit := na
        stopLoss := na
        short := na


//-----------------------------LONG/SHORT CONDITION-------------------------//

// Conditions to create two stop orders (one for Long and one for Short) and SL & TP calculation
if nr and inRange and strategy.position_size == 0
    stopPriceLong := high[4]
    takeProfitLong := high[4] + (high[4] - low[4])
    stopLossLong := high[4] - (high[4] - low[4])*stopLossInput
    qtyLong = cashOrder/stopPriceLong
    strategy.entry("Long", strategy.long, qtyLong, stop=stopPriceLong)
    strategy.exit("Exit Long", "Long", limit=takeProfitLong ,stop=stopLossLong)
    stopPriceShort := low[4]
    takeProfitShort := low[4] - (high[4] - low[4])
    stopLossShort := low[4] + (high[4] - low[4])*stopLossInput
    qtyShort = cashOrder/stopPriceShort
    strategy.entry("Short", strategy.short, qtyShort, stop=stopPriceShort)
    strategy.exit("Exit Short", "Short", limit=takeProfitShort ,stop=stopLossShort)


//--------------------------PLOTTING ELEMENT----------------------------//

plotshape(nr, "NR", shape.arrowdown, location.abovebar, color.rgb(255, 132, 0), text= "NR4", size=size.huge)
plot(stopPriceLong, "Stop Order", color.blue, 3, plot.style_linebr)
plot(stopPriceShort, "Stop Order", color.blue, 3, plot.style_linebr)
plot(takeProfit, "Take Profit", color.green, 3, plot.style_linebr)
plot(stopLoss, "Stop Loss", color.red, 3, plot.style_linebr)

Mehr