Momentum-Strategie für den kurzfristigen Handel basierend auf Preisausbrüchen und -rückgängen
ChaoZhang
Überblick
Die Strategie basiert auf einer Kombination von Preisbruch und Durchschnittsrückgang und verwendet mehrere Indikatoren zur Bestätigung und Filterung, um Trends zu beurteilen und zu verfolgen. Die Strategie eignet sich für Short- und Mid-Line-Handels, um kleine Gewinne durch strenge Ein- und Ausstiegsmechanismen zu sperren.
Strategieprinzip
Die HMA-Mittellinie dient als Referenzlinie, um die Richtung der Preisentwicklung zu bestimmen. Preise, die über der Mittellinie liegen, sind positiv, Preise, die unter der Mittellinie liegen, sind negativ.
Der SSL-Kanal dient als Bestätigungsindikator, der Trends durch die Richtung des Kanals und die Preisbeziehung bestätigt.
TDFI ist ein Indikator für die Qualität der Leistung. Nur wenn die Leistung ein bestimmtes Niveau erreicht hat, kann man zugelassen werden.
Der RVI-Indikator dient als Ausstiegs-Indikator. Wenn sich die Form der RVI-Linie ändert, wird der Trend beendet und die Position beendet.
Der ATR-Indikator berechnet Stop Loss und Stop Out.
Einstiegsvoraussetzungen: Der Preis überschreitet die Benchmark, die Richtung des SSL-Kanals stimmt mit dem Preis überein, TDFI erreicht den Schwellenwert.
Ausgangskonditionen: Veränderung der Form der RVI-Zahlenlinie oder Preisrückschlag über die Benchmark und den SSL-Kanal.
Analyse der Stärken
Mit einer Kombination aus mehreren Indikatoren kann ein falscher Durchbruch wirksam gefiltert werden.
Strenge Eintrittsbedingungen mit Exit-Stopp, die Ein-Stopp-Kontrolle ist möglich.
Das ist eine gute Gelegenheit, um die Preisentwicklung zu nutzen und zusätzliche Einnahmen zu erzielen.
Die Optimierung der Kennzahlen ist groß und kann für verschiedene Produkte und Perioden angepasst werden.
Risikoanalyse
Es ist unwahrscheinlich, dass sich der Trend umkehren wird, und es besteht die Gefahr, dass die Überdosis weiter nach oben / nach unten gejagt wird.
Kurzfristige Operationen mit dem Risiko eines Überhandels.
Die Einstellung der Stop-Loss-Position ist subjektiv und kann zu locker oder zu eng sein.
Eine falsche Einstellung der Parameter kann zu häufigen oder unzureichenden Transaktionen führen.
Optimierungsrichtung
Erhöhung der Indikatoren für Trendbeurteilung, um die Genauigkeit der Trendrichtung zu gewährleisten
Hinzugefügt wird ein Rückschlagsignal, um die Wahrscheinlichkeit zu verringern, dass ein Übergewicht nach oben/nach unten gejagt wird.
Erwägen Sie, die ATR-Dynamik auf den ATR-Trailing-Stop umzustellen, um den Stop-Loss dynamischer zu gestalten.
Verschiedene homogene Systeme werden getestet, um eine Optimierung der Parameter zu finden.
Optimierung der Parameter des Index und Anpassung der Parameter an die spezifischen Handelsarten.
Zusammenfassen
Die Strategie wird durch mehrere Indikatoren bestätigt und ermöglicht die Präzision der Handelssignale. Strenge Stop-Loss-Mechanismen kontrollieren den Einzelschaden. Die Strategie ist für Personen geeignet, die mit technischen Analyseoperationen vertraut sind.
/*backtest
start: 2022-11-06 00:00:00
end: 2023-11-12 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Designed per No Nonsense Forex VP rules
//Made to be as modular as possible, so we can swap the indicators in and out.
//Originated from causecelebre
//Tried to put in as much VP rules as possible
///////////////////////////////////////////////////
//Rules Implemented:
///////////////////////////////////////////////////
// - SL 1.5 x ATR
// - TP 1 x ATR
//
// - Entry conditions
//// - Entry within 1 candles of baseline + 1 x confirmation + volume
//// - Entry only if baseline is < 1 x ATR
// - Exit conditions
//// - Exit on exit indicator or when baseline or confirmation flip
///////////////////////////////////////////////////
//Trades entries
///////////////////////////////////////////////////
// - First entry L1 or S1 with standard SL and TP
// - Second entry L2 or S2 with standard SL and exit upon the exit conditions
///////////////////////////////////////////////////
//Included Indicators and settings
///////////////////////////////////////////////////
// - Baseline = HMA 20
// - Confirmtion = SSL 10
// - Volume = TDFI 4
// - Exit = RVI 4
///////////////////////////////////////////////////
//Credits
// Strategy causecelebre https://www.tradingview.com/u/causecelebre/
// TDFI causecelebre https://www.tradingview.com/u/causecelebre/
// SSL Channel ErwinBeckers https://www.tradingview.com/u/ErwinBeckers/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
strategy(title="NNFX Strategy | jh", overlay = true )
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Set the main stuff ****
///////////////////////////////////////////////////
//Price
price = close
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ATR stuff
///////////////////////////////////////////////////
atrLength = input(14, "ATR Length")
slMultiplier = input(1.5, "SL")
tpMultiplier = input(1, "TP")
atr = atr(atrLength)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Baseline ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//HMA 20
///////////////////////////////////////////////////
hmaslowlength = input(20, minval=1)
src = input(close, title="Source")
slowhullma = wma(2*wma(src, hmaslowlength/2)-wma(src, hmaslowlength), round(sqrt(hmaslowlength)))
plot(slowhullma, title = "baseline", color = yellow, linewidth=2, transp=0)
///////////////////////////////////////////////////
// Base Signals
///////////////////////////////////////////////////
///////////////////////////////////////////////////
baseline = slowhullma
//Signals based on crossover
//baseShort = crossover(baseLine, price)
//baseLong = crossover(price, baseLine)
//Signals based on signal position
b_Short = baseline > price ? 1 : 0
l_Long = baseline < price ? 1 : 0
baseShort = b_Short
baseLong = l_Long
///////////////////////////////////////////////////
//ATR Check
///////////////////////////////////////////////////
distBasefromPrice = abs(baseline - price)
atrCheck = distBasefromPrice <= atr ? 1 : 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Confirmation ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//SSL Channel
///////////////////////////////////////////////////
sslLen=input(title="SSL Period", defval=10)
smaHigh=sma(high, sslLen)
smaLow=sma(low, sslLen)
Hlv = na
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh: smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////////////////////////////////////////////
//Confirm Signals
///////////////////////////////////////////////////
c_Up = sslUp
c_Down = sslDown
//Signals based on crossover
c_Long = crossover(c_Up, c_Down)
c_Short = crossover(c_Down, c_Up)
confirmLong = c_Long
confirmShort = c_Short
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Volume Indicator Start ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//TDFI
///////////////////////////////////////////////////
lookback = input(4, title = "TDFI Lookback")
filterHigh = input(0.05, title = "Filter High")
filterLow = input(-0.05, title = "Filter Low")
mma = ema(price * 1000, lookback)
smma = ema(mma, lookback)
impetmma = mma - mma[1]
impetsmma= smma - smma[1]
divma = abs(mma - smma)
averimpet = (impetmma + impetsmma) / 2
number = averimpet
pow = 3
result = na
for i = 1 to pow - 1
if i == 1
result := number
result := result * number
tdf = divma * result
ntdf = tdf / highest(abs(tdf), lookback * 3)
///////////////////////////////////////////////////
//Volume Signals
///////////////////////////////////////////////////
v_Long = ntdf > filterHigh ? 1 : 0
v_Short = filterLow > ntdf ? 1 : 0
volumeLong = v_Long
volumeShort = v_Short
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **** Exit Indicator ****
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//RVI 4
///////////////////////////////////////////////////
rgvlen = input(4, title="RVI Length", minval=1)
rvi = sum(swma(close-open), rgvlen)/sum(swma(high-low),rgvlen)
sig = swma(rvi)
///////////////////////////////////////////////////
//Exit Signals
///////////////////////////////////////////////////
e_Short = crossover(rvi, sig)
e_Long = crossover(sig, rvi)
exitOutofShort = e_Short
exitOutofLong = e_Long
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// **************************** Logic to handle NNFX rules ****************************
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Checking for base and confirmation indication with 1 candle difference
baseandConfirmLong = ((baseLong[0] and confirmLong[0]) or (baseLong[1] and confirmLong[0]) or (baseLong[1] and confirmLong[1]) or (baseLong[0] and confirmLong[1])) ? 1 : 0
baseandConfirmShort = ((baseShort[0] and confirmShort[0]) or (baseShort[1] and confirmShort[0]) or (baseShort[1] and confirmShort[1]) or (baseShort[0] and confirmShort[1])) ? 1 : 0
//Combining with volume with 1 candle difference
enterLong = ((baseandConfirmLong[0] and volumeLong[0]) or (baseandConfirmLong[1] and volumeLong[0]) or (baseandConfirmLong[1] and volumeLong[1]) or (baseandConfirmLong[0] and volumeLong[1])) ? 1 : 0
enterShort = ((baseandConfirmShort[0] and volumeShort[0]) or (baseandConfirmShort[1] and volumeShort[0]) or (baseandConfirmShort[1] and volumeShort[1]) or (baseandConfirmShort[0] and volumeShort[1])) ? 1 : 0
//Exit on base or confirmation flip over
baseandConfirmFliptoShort = ((baseShort[0] or confirmShort[0]) or (baseShort[1] or confirmShort[0]) or (baseShort[1] or confirmShort[1]) or (baseShort[0] or confirmShort[1])) ? 1 : 0
baseandConfirmFliptoLong = ((baseLong[0] or confirmLong[0]) or (baseLong[1] or confirmLong[0]) or (baseLong[1] or confirmLong[1]) or (baseLong[0] or confirmLong[1])) ? 1 : 0
//Exit on base and confirmation flip or exit indicator
exitLong = exitOutofLong or baseandConfirmFliptoShort ? 1 : 0
exitShort = exitOutofShort or baseandConfirmFliptoLong ? 1 : 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Entries and Exits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (year>2009)
//Long entries with standard 1.5 ATR for SL, 1 ATR for TP
long_sl = price - atr * slMultiplier
long_tp = price + atr * tpMultiplier
strategy.entry("L1", strategy.long, when = enterLong and atrCheck)
strategy.exit("L1 SL Exit", "L1", stop = long_sl, limit = long_tp)
strategy.close("L1", when = exitLong)
//Long entries with no TP
strategy.entry("L2", strategy.long, when = enterLong and atrCheck)
strategy.exit("L2 SL Exit", "L2", stop = long_sl)
strategy.close("L2", when = exitLong)
//Short entries with standard 1.5 ATR for SL, 1 ATR for TP
short_sl = price + atr * slMultiplier
short_tp = price - atr * tpMultiplier
strategy.entry("S1", strategy.short, when = enterShort and atrCheck)
strategy.exit("S1 SL Exit", "Short1", stop = short_sl, limit = short_tp)
strategy.close("S1", when = exitShort)
//Short entries with no TP
strategy.entry("S2", strategy.short, when = enterShort and atrCheck)
strategy.exit("S2 Exit", stop = short_sl)
strategy.close("S2", when = exitShort)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//End
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////