Diese Strategie verwendet zeitübergreifende technische Indikatoren, um die Trendrichtung zu ermitteln, kombiniert mit Trendfilterung und Volatilitätsfilterung, um einen risikoarmen Trendverfolgungshandel zu erreichen.
Verwenden Sie High-Low-Punkte-Breakthroughs, um Kauf- und Verkaufssignale zu bestimmen.
Der Trendflex-Indikator bestimmt die Haupttrendrichtung. Dieser Indikator kombiniert doppelte Glättungstechniken und kann effektiv Trendmitteabschnitte identifizieren. Ein Wert über 1 zeigt einen Aufwärtstrend an, während ein Wert unter -1 einen Abwärtstrend anzeigt. Hier benötigen wir Trendflex > 1 für Longs und < -1 für Shorts, wodurch Konsolidierungszustände ausgefiltert werden.
Verwenden Sie Bollinger-Bänder, um Schwingungsbereiche zu identifizieren. Vermeiden Sie Longs und Shorts, wenn der Schlusskurs innerhalb des Bandes liegt.
Verwenden Sie bewegliche Stop-Loss- und Take-Profit-Positionen.
Durch die Kombination von zeitübergreifenden Indikatoren und Doppelglättungstechniken können effektiv Trendrichtungen ermittelt und schwankende Märkte vermieden werden.
Die Berücksichtigung sowohl der Trendrichtung als auch der Volatilitätsmuster macht Handelssignale zuverlässiger.
Ein angemessener Stop-Loss- und Take-Profit-Einstellungen verhindert, dass Verluste zunehmen.
Die Strategie ist relativ einfach und leicht umzusetzen.
Durchbruchsignale können falsche Ausbrüche haben, was zu falschen Trades führt.
Festzyklusparameter können sich nicht an Marktveränderungen anpassen, eine dynamische Optimierung der Parameter kann in Betracht gezogen werden.
Das Fehlen von Preisstauern verhindert nicht riesige Verluste durch extreme Marktbedingungen.
Festgelegte Stop-Loss- und Take-Profit-Punkte können nicht entsprechend der Marktvolatilität intelligent angepasst werden.
Es sollte in Erwägung gezogen werden, weitere Trendbeurteilungsindikatoren hinzuzufügen, um eine Strategiekombination zu bilden, um die Beurteilungsgenauigkeit zu verbessern.
Hinzufügen von Modulen zur Identifizierung von Schwankungen, um den Handel zu unterbrechen, wenn die Schwankungen stark sind, um das Risiko zu reduzieren.
Einführung von Algorithmen für maschinelles Lernen zur Dynamikoptimierung von Parametern.
Hinzufügen von Preis-Stop-Loss-Modulen, um Verluste zu stoppen, wenn Verluste einen bestimmten Schwellenwert erreichen.
Berechnen Sie die Profit- und Stop-Loss-Kennzahlen basierend auf der Marktvolatilität, um eine intelligente Anpassung von Profit- und Stop-Loss-Kennzahlen zu erzielen.
Insgesamt ist diese Strategie relativ stabil und zuverlässig, hat aber auch Raum für Verbesserungen. Die Kernidee besteht darin, die Trendrichtung über Zyklen hinweg zu bestimmen und dann mithilfe von Trendstärkenindikatoren und Volatilitätsindikatoren zu filtern, um hochwertige Signale zu generieren. Diese einfache und praktische Strategie eignet sich sehr gut für die Verfolgung mittelfristiger und langfristiger Trends. Durch die Einführung von mehr bedingten Urteilen und dynamischer Parameteroptimierung kann der Strategieeffekt weiter verbessert werden.
/*backtest
start: 2023-08-27 00:00:00
end: 2023-09-26 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Eltrut", shorttitle="Eltrut Strat", overlay=true, pyramiding=0, default_qty_type= strategy.percent_of_equity,calc_on_order_fills=false, slippage=25,commission_type=strategy.commission.percent,commission_value=0.075)
testStartYear = input(2016, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// R E F L E X / T R E N D F L E X
f_supersmoother(_src,_len)=>
pi = 2 * asin(1)
_a = exp(-sqrt(2) * pi / _len)
_c2 = 2 * _a * cos(sqrt(2) * pi / _len)
_c3 = -_a * _a
_c1 = 1 - _c2 - _c3
_out = 0.0
_out := _c1 * _src + _c2 * nz(_out[1],nz(_src[1],_src)) + _c3 * nz(_out[2],nz(_src[2],nz(_src[1],_src)))
f_IQIFM(_src1,_max)=>
_src = _src1 < 0.001 ? _src1 * 10000 : _src1
_imult = 0.635, _qmult = 0.338 , _inphase = 0.0, _quad = 0.0
_re = 0.0, _im = 0.0, _deltaphase = 0.0, _instper = 0.0, _per = 0.0, _v4 = 0.0
_v1 = _src - nz(_src[7])
_inphase := 1.25 * (nz(_v1[4]) - _imult * _v1[2]) + _imult * nz(_inphase[3])
_quad := _v1[2] - _qmult * _v1 + _qmult * nz(_quad[2])
_re := 0.2 * (_inphase * _inphase[1] + _quad * _quad[1]) + 0.8 * nz(_re[1])
_im := 0.2 * (_inphase * _quad[1] - _inphase[1] * _quad) + 0.8 * nz(_im[1])
if _re != 0.0
_deltaphase := atan(_im / _re)
for i = 0 to _max
_v4 := _v4 + _deltaphase[i]
if _v4 > 4 * asin(1) and _instper == 0.0
_instper := i
if _instper == 0.0
_instper := nz(_instper[1])
_per := 0.25 * _instper + 0.75 * nz(_per[1])
_per
f_flex(_src1, _fixed_len, _reflex) =>
_src = _src1
_len = _fixed_len
_ss1 = f_supersmoother(_src, _len)
_ss = _ss1
_slope = (_ss[_len] - _ss) / _len
_sum = 0.0
for _i = 1 to _len
_c1 = _reflex ? _ss + _i * _slope - _ss[_i] : _ss - _ss[_i]
_sum := _sum + _c1
_sum := _sum / _len
_ms = 0.0
_ms := 0.04 * pow(_sum,2) + 0.96 * nz(_ms[1])
_flex1 = _ms != 0 ? _sum / sqrt(nz(_ms)) : 0.0
_flex = _flex1
_flex
rflx = f_flex(close, 20, true)
trndflx = f_flex(close, 20, false)
// S I G N A L
hi7 = highest(7)
lo7 = lowest(7)
long_cond = crossunder(close, lo7[1])
short_cond = crossover(close, hi7[1])
// F I L T E R S
long_filter1 = trndflx < 1
short_filter1 = trndflx > -1
basis = sma(close, 35)
dev = 3 * stdev(close, 35)
long_filter2 = close > basis - dev
short_filter2 = close < basis + dev
// S T R A T E G Y
long = long_cond and long_filter1 and long_filter2
short = short_cond and short_filter1 and short_filter2
if( true)
strategy.entry("Long", strategy.long, when = long)
strategy.entry("Long", strategy.long, when = short)
// User Options to Change Inputs (%)
stopPer = input(3, title='Stop Loss %', type=input.float) / 100
takePer = input(9, title='Take Profit %', type=input.float) / 100
// Determine where you've entered and in what direction
longStop = strategy.position_avg_price * (1 - stopPer)
shortStop = strategy.position_avg_price * (1 + stopPer)
shortTake = strategy.position_avg_price * (1 - takePer)
longTake = strategy.position_avg_price * (1 + takePer)
if strategy.position_size > 0
strategy.exit(id="Exit Long", stop=longStop, limit=longTake)
if strategy.position_size < 0
strategy.exit(id="Exit Short", stop=shortStop, limit=shortTake)
// P L O T
plotshape(long, color = #1e90ff, text = "", style=shape.triangleup, location=location.belowbar, size=size.tiny)
plotshape(short, color = #ff69b4, text = "", style=shape.triangledown, location=location.abovebar, size=size.tiny)
alertcondition(long, "Long", "Enter Long")
alertcondition(short, "Short", "Enter S")