Diese Strategie berechnet zwei volumengewichtete gleitende Durchschnitte als schnelle und langsame Linien. Sie bestimmt die Trendrichtung auf der Grundlage der Differenz zwischen den beiden Linien und nimmt entsprechend Long- oder Short-Positionen ein. Die Strategie ist einfach und effektiv bei der Verfolgung von Markttrends.
Berechnung der schnellen und langsamen Linien unter Verwendung volumengewichteter gleitender Durchschnitte auf der Grundlage der vom Benutzer definierten schnellen und langsamen Perioden.
Berechnen Sie den Unterschied zwischen den schnellen und langsamen Linien.
Bestimmung der Trendrichtung: Das Überschreiten der schnellen Linie über der langsamen Linie zeigt einen Aufwärtstrend an und das Überschreiten darunter zeigt einen Abwärtstrend an.
Veröffentlichen Sie lange/kurze Signale. Gehen Sie lang, wenn die schnelle Linie über die langsame Linie geht. Gehen Sie kurz, wenn die schnelle Linie unter die langsame Linie geht.
Einstellen von Stoppverlusten auf Basis eines vom Benutzer definierten festen Prozentsatzes oder dynamischen ATR.
Ausgangsregeln: Schließen, wenn ein Stop-Loss erreicht wird oder ein Rückschlagsignal angezeigt wird.
Verwendet quantitative Indikatoren, um Trends zu erkennen und falsche Ausbrüche zu vermeiden.
Die Kombination von schneller und langsamer Linie filtert Marktlärm aus und verhindert Überhandelungen.
Der Stop-Loss kontrolliert das Abwärtsrisiko effektiv.
Einfach und leicht verständlich.
Anpassbare Parameter für verschiedene Produkte und Zeitrahmen.
Eine unsachgemäße Einstellung der Parameter kann zu einem Überhandel oder zu verpassten Trends führen.
Festgesetzte Stop-Loss-Regelungen können für sich ändernde Marktbedingungen zu rigid sein.
Änderungen der Volumen- und Preisverhältnisse können Auswirkungen auf die Wirksamkeit haben.
Das Risiko 1 kann durch Parameteroptimierung gemildert werden.
Das Risiko 2 kann durch dynamische ATR-Stop-Loss behandelt werden.
Risiko 3 muss Volumenänderungen überwachen.
Verschiedene Kombinationen von schnellen und langsamen Linienparametern testen.
Versuchen Sie andere Volumenpreisindikatoren wie OBV, William
Hinzufügen von volatilitätsbasierten Stopps.
Bewertung der Kombination mit anderen Indikatoren.
Testen Sie die Wirksamkeit verschiedener Handelsinstrumente.
Diese Strategie verwendet schnelle und langsame quantifizierte gleitende Durchschnitte, um Trends mit einfacher Logik zu verfolgen.
/*backtest
start: 2023-08-18 00:00:00
end: 2023-09-17 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("EVWMA 6HR", overlay=false, precision=2, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
// Credit to QuantNomad for the main idea behind this code
/////////////// Time Frame ///////////////
_1 = input(false, "════════ Test Period ═══════")
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
///////////// EVWMA /////////////
_2 = input(false, "════════ EVMA ═══════")
fast_sum_length = input(5, title = "Fast Sum Length", type = input.integer)
slow_sum_length = input(11, title = "Slow Sum Length", type = input.integer)
fast_vol_period = sum(volume, fast_sum_length)
slow_vol_period = sum(volume, slow_sum_length)
fast_evwma = 0.0
fast_evwma := ((fast_vol_period - volume) * nz(fast_evwma[1], close) + volume * close) / (fast_vol_period)
slow_evwma = 0.0
slow_evwma := ((slow_vol_period - volume) * nz(slow_evwma[1], close) + volume * close) / (slow_vol_period)
diff = fast_evwma - slow_evwma
/////////////// Strategy ///////////////
long = fast_evwma > slow_evwma
short = fast_evwma < slow_evwma
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
SL_type = input("Fixed", options=["Fixed", "ATR Derived"], title="Stop Loss Type")
sl_inp = input(9.0, title='Fixed Stop Loss %') / 100
atrLkb = input(20, minval=1, title='ATR Stop Period')
atrMult = input(1.5, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop1 = 0.0
longStop1 := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop1[1]
shortStop1 = 0.0
shortStop1 := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop1[1]
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
_5 = input(false, "══════ Longs or Shorts ═════")
useLongs = input(true, title="Use Longs")
useShorts = input(true, title="Use Shorts")
/////////////// Execution ///////////////
if testPeriod()
if useLongs
strategy.entry("L", strategy.long, when=long)
strategy.exit("L SL", "L", stop = SL_type == "Fixed" ? long_sl : longStop1, when=since_longEntry > -1)
if useShorts
strategy.exit("S SL", "S", stop = SL_type == "Fixed" ? short_sl : shortStop1, when=since_shortEntry > -1)
strategy.entry("S", strategy.short, when=short)
if not useShorts
strategy.close("L", when=short)
if not useLongs
strategy.close("S", when=long)
/////////////// Plotting ///////////////
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
p1 = plot(diff, title = "Delta", color = long ? color.lime : short ? color.red : na, transp=0)
p2 = plot(0, color = color.white)
fill(p1, p2, color = long ? color.lime : short ? color.red : na, transp=60)