Diese Strategie identifiziert die Kursentwicklungsrichtung, indem sie drei glättete gleitende Durchschnitte, den Relative Strength Index (RSI) und den Williams-Indikator kombiniert und nach Handelsmöglichkeiten sucht, wenn sich der Trend umkehrt. Sie geht lang (short), wenn sich die schnellen, mittleren und langsamen gleitenden Durchschnitte nach oben (nach unten) ausrichten, der RSI über (unter) 50 liegt und ein nach unten (nach oben) Williams-Signal erscheint. Der Stop-Loss wird auf einen bestimmten Prozentsatz des Einstiegspreises gesetzt und mit einem bestimmten Prozentsatz in der günstigen Richtung vom Einstiegspreis profitiert.
Die Strategie verwendet drei gleitende Durchschnitte mit verschiedenen Perioden, einschließlich schneller, mittlerer und langsamer MA. Wenn der schnelle MA über den mittleren MA überschreitet, signalisiert er einen Aufwärtstrend. Wenn der schnelle MA unter den mittleren MA überschreitet, signalisiert er einen Abwärtstrend. Nachdem der Aufwärtstrend oder der Abwärtstrend identifiziert wurde, wartet die Strategie auf die erste Handelsmöglichkeit.
Insbesondere, nachdem der Preis in einen Aufwärtstrend eingeht, wartet die Strategie, bis die folgenden fünf Bedingungen erfüllt sind, bevor sie lang geht:
Die schnellen, mittleren und langsamen MAs zeigen alle nach oben.
RSI über 50;
Ein nachlassendes Williams-Muster erscheint;
Der Preis überschreitet die langsame MA;
Es gibt keine aktuelle Position.
Wenn der Kurs einen Abwärtstrend erreicht hat, wartet die Strategie, bis die folgenden fünf Bedingungen erfüllt sind, bevor sie kurz geht:
Die schnellen, mittleren und langsamen MAs zeigen alle nach unten.
RSI unter 50;
Es erscheint ein Williams-Muster nach oben.
Der Preis überschreitet den langsamen MA;
Es gibt keine aktuelle Position.
Nach dem Long- oder Short-Gehen setzt die Strategie einen Stop-Loss auf einen bestimmten Prozentsatz unter dem Einstiegspreis und ein Take-Profit-Ziel auf einen bestimmten Prozentsatz über dem Einstiegspreis.
Die Kombination mehrerer Indikatoren zur Bestätigung von Einträgen kann falsche Ausbrüche effektiv vermeiden. Die dreifachen MAs identifizieren die Trendrichtung, Williams fängt Umkehrsignale auf und der RSI filtert die preisaktion aus, was die Genauigkeit der Einträge gemeinsam verbessert.
Die Einstellung von Stop Loss und Take Profit kann das Risiko/Gewinn jedes Handels gut kontrollieren und sicherstellen, dass Gewinntrades die Verliertrades übersteigen.
Die Strategie Logik ist klar und leicht zu verstehen. Die Parameter sind vernünftig festgelegt. Es passt für Händler auf verschiedenen Ebenen.
Indikatoren können während von Range-bound Markten falsche Signale erzeugen, was zu unnötigen Einträgen führt.
Die schnelle und mittlere MA-Überschneidung kann falsche Ausbrüche aufweisen.
Wenn der Stop-Loss zu nahe am Einstiegspreis liegt, kann er vorzeitig gestoppt werden.
Wenn der Take-Profit zu weit vom Einstiegspreis entfernt ist, wird er möglicherweise nicht getroffen.
Versuche verschiedene Parameterkombinationen für die drei MA und RSI.
Fügen Sie andere Indikatoren hinzu, wie zum Beispiel Volumen, um zu überprüfen, ob das Volumen bei Ausbrüchen steigt.
Prüfparameter, die je nach verschiedenen Produkten ermittelt werden.
Zeichnen Sie Gewinnkurven auf der Grundlage von Backtest-Ergebnissen, um Stop Loss und Take Profit zu optimieren.
Versuchen Sie den Papierhandel, bevor Sie die Optimierung der Parameter ermöglichen.
Die Strategie hat insgesamt eine klare Logik, indem Positionen mit einer Kombination von Indikatoren eingegeben und verlassen werden, was das Risiko effektiv kontrolliert. Es gibt großen Raum für die Optimierung von Parametern. Durch das Testen verschiedener Parameter-Einstellungen kann diese Strategie zu einer stetig profitablen quantitativen Handelsstrategie werden. Allerdings kann keine Strategie Verluste vollständig vermeiden. Händler müssen Handelsdisziplinen befolgen - Gewinn machen, wenn sie gewinnen und Verluste reduzieren, wenn sie verlieren.
/*backtest
start: 2023-08-28 00:00:00
end: 2023-09-27 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//This script is a combination of 3 smoothed moving averages, and RSI. When moving averages are aligned upward (downward) and RSI is above (below) 50 and a down (up) William fractal appears, it enters long (short) position. Exiting from long and short entries are defined by StopLoss and TargetProfit.
//@version=5
strategy(title="3SmmaCrossUp + Fractal + RSI", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100, currency=currency.USD, commission_type=strategy.commission.percent, commission_value=0.03)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// inputs
// Global
src = input(close, title="Source")
stopLoss = input.float(defval = 0.1, title = "Stop Loss %", minval = 0, maxval=100, step = 0.1)
targetProfit = input.float(defval = 0.4, title = "Target Profit %", minval = 0, maxval=100, step = 0.1)
// Smooth Moving Average
fastSmmaLen = input.int(21, minval=1, title="Fast Length", group = "Smooth Moving Average")
midSmmaLen = input.int(50, minval=1, title="Mid Length",group = "Smooth Moving Average")
slowSmmaLen = input.int(200, minval=1, title="Slow Length",group = "Smooth Moving Average")
// RSI
rsiLen = input.int(defval=14, title="length", minval=1, maxval=1000, step=1, group="RSI")
// Fractals
n = input.int(title="Periods", defval=2, minval=2, group = "Fractals")
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// initialization
var waitingFirstTradeInUpwardTrend = false
var waitingFirstTradeInDownwardTrend = false
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// functions
smma(ma, src, len) =>
smma = 0.0
smma := na(smma[1]) ? ma : (smma[1] * (len - 1) + src) / len
smma
fractals(n, highs, lows) =>
// UpFractal
bool upflagDownFrontier = true
bool upflagUpFrontier0 = true
bool upflagUpFrontier1 = true
bool upflagUpFrontier2 = true
bool upflagUpFrontier3 = true
bool upflagUpFrontier4 = true
for i = 1 to n
upflagDownFrontier := upflagDownFrontier and (highs[n-i] < highs[n])
upflagUpFrontier0 := upflagUpFrontier0 and (highs[n+i] < highs[n])
upflagUpFrontier1 := upflagUpFrontier1 and (highs[n+1] <= highs[n] and highs[n+i + 1] < highs[n])
upflagUpFrontier2 := upflagUpFrontier2 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+i + 2] < highs[n])
upflagUpFrontier3 := upflagUpFrontier3 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+i + 3] < highs[n])
upflagUpFrontier4 := upflagUpFrontier4 and (highs[n+1] <= highs[n] and highs[n+2] <= highs[n] and highs[n+3] <= highs[n] and highs[n+4] <= highs[n] and highs[n+i + 4] < highs[n])
flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4
upFractal = (upflagDownFrontier and flagUpFrontier)
// downFractal
bool downflagDownFrontier = true
bool downflagUpFrontier0 = true
bool downflagUpFrontier1 = true
bool downflagUpFrontier2 = true
bool downflagUpFrontier3 = true
bool downflagUpFrontier4 = true
for i = 1 to n
downflagDownFrontier := downflagDownFrontier and (lows[n-i] > lows[n])
downflagUpFrontier0 := downflagUpFrontier0 and (lows[n+i] > lows[n])
downflagUpFrontier1 := downflagUpFrontier1 and (lows[n+1] >= lows[n] and lows[n+i + 1] > lows[n])
downflagUpFrontier2 := downflagUpFrontier2 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+i + 2] > lows[n])
downflagUpFrontier3 := downflagUpFrontier3 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+i + 3] > lows[n])
downflagUpFrontier4 := downflagUpFrontier4 and (lows[n+1] >= lows[n] and lows[n+2] >= lows[n] and lows[n+3] >= lows[n] and lows[n+4] >= lows[n] and lows[n+i + 4] > lows[n])
flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4
downFractal = (downflagDownFrontier and flagDownFrontier)
[upFractal, downFractal]
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// calcs
[upFractal, downFractal] = fractals(n, high, low)
rsiIsHigh = ta.rsi(src, rsiLen) >= 50
slowMa = ta.sma(src, slowSmmaLen)
midMa = ta.sma(src, midSmmaLen)
fastMa = ta.sma(src, fastSmmaLen)
slowSmma = smma(slowMa ,src, slowSmmaLen)
midSmma = smma(midMa, src, midSmmaLen)
fastSmma = smma(fastMa, src, fastSmmaLen)
isFastSmmaUpward = ta.rising(fastSmma, 1)
isMidSmmaUpward = ta.rising(midSmma, 1)
isSlowSmmaUpward = ta.rising(slowSmma, 1)
isFastSmmaDownward = ta.falling(fastSmma, 1)
isMidSmmaDownward = ta.falling(midSmma, 1)
isSlowSmmaDownward = ta.falling(slowSmma, 1)
slowMovingAveragesAreUpward = isMidSmmaUpward and isSlowSmmaUpward
slowMovingAveragesAreDownward = isMidSmmaDownward and isSlowSmmaDownward
justEnteredUpwardTrend = ta.crossover(fastSmma, midSmma) ? true : false
justEnteredDownwardTrend = ta.crossunder(fastSmma, midSmma) ? true : false
waitingFirstTradeInUpwardTrend := justEnteredUpwardTrend == true ? true : (isFastSmmaDownward or isMidSmmaDownward or isSlowSmmaDownward ? false : waitingFirstTradeInUpwardTrend)
waitingFirstTradeInDownwardTrend := justEnteredDownwardTrend == true ? true : (isFastSmmaUpward or isMidSmmaUpward or isSlowSmmaUpward ? false : waitingFirstTradeInDownwardTrend)
priceCrossedOverSlowMa = ta.crossover(close, slowSmma)
priceCrossedUnderSlowMa = ta.crossunder(close, slowSmma)
enterLongCondition = barstate.isconfirmed and low > fastSmma and rsiIsHigh and (downFractal or priceCrossedOverSlowMa) and waitingFirstTradeInUpwardTrend and strategy.position_size == 0
enterShortCondition = barstate.isconfirmed and high < fastSmma and (not rsiIsHigh) and (upFractal or priceCrossedUnderSlowMa) and waitingFirstTradeInDownwardTrend and strategy.position_size == 0
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// strategy
if(enterLongCondition)
strategy.entry(id="L", direction=strategy.long)
waitingFirstTradeInUpwardTrend := false
if(enterShortCondition)
strategy.entry(id="S", direction=strategy.short)
waitingFirstTradeInDownwardTrend := false
if(strategy.position_size > 0)
strategy.exit(id="EL", stop=strategy.position_avg_price * (1 - stopLoss/100), limit=strategy.position_avg_price * (1+targetProfit/100))
if(strategy.position_size < 0)
strategy.exit(id="ES", stop=strategy.position_avg_price * (1 + stopLoss/100), limit=strategy.position_avg_price * (1-targetProfit/100))
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// plots
plot(series = slowSmma, title="Slow SMMA", linewidth=3)
plot(series = midSmma, title="Mid SMMA", linewidth=2)
plot(series = fastSmma, title="Fast SMMA", linewidth=1)
plotchar(series=rsiIsHigh, title='rsiIsHigh', char='')
plotchar(series=justEnteredUpwardTrend, title='justEnteredUpwardTrend', char='')
plotchar(series=justEnteredDownwardTrend, title='justEnteredDownwardTrend', char='')
plotchar(series=waitingFirstTradeInUpwardTrend, title='waitingFirstTradeInUpwardTrend', char='')
plotchar(series=waitingFirstTradeInDownwardTrend, title='waitingFirstTradeInDownwardTrend', char='')
plotchar(series=enterLongCondition, title='enterLongCondition' , char='')
plotchar(series=enterShortCondition, title='enterShortCondition' , char='')
plotshape(series=upFractal, title='upFractal', style=shape.triangleup, location=location.abovebar, color=#009688, size = size.tiny)
plotshape(series=downFractal, title='downFractal', style=shape.triangledown, location=location.belowbar, color=color.red, size = size.tiny)