Die Ressourcen sind geladen. Beförderung...

Modulo Logik mit EMA-Filterstrategie

Schriftsteller:ChaoZhang, Datum: 2023-12-13 15:55:07
Tags:

Übersicht

Diese Strategie kombiniert modulo-arithmetische Operationen und exponentielle gleitende Durchschnitte, um einen starken Zufallsfilter zur Bestimmung der Positionsrichtung zu erstellen. Er berechnet zuerst den Rest des Preises durch eine bestimmte Zahl und ein Handelssignal wird erzeugt, wenn der Rest 0 beträgt. Wenn dieses Signal unterhalb der EMA-Linie ist, gehen Sie kurz; wenn darüber, gehen Sie lang. Diese Strategie integriert die Zufälligkeit mathematischer Operationen und den Beurteilungstrend technischer Indikatoren und nutzt die Quervalidierung zwischen Indikatoren verschiedener Zyklen, um effektiv einen Teil des Marktlärms auszufiltern.

Strategie Logik

Setzen Sie den Preis-Eingabewert a auf schließen, modifizierbar; setzen Sie den Teiler b auf 4, modifizierbar.
Berechnen Sie den Restmodul von a geteilt durch b, und bestimmen Sie, ob Modul gleich 0 ist.
Längen des EMA (MALen) auf 70 Perioden standardmäßig als Messwert für den mittelfristigen bis langfristigen Trend festlegen.
Wenn Modulo gleich 0 ist, wird ein Handelssignal mit einer geraden Zahl generiert. In Kombination mit der EMA-Beziehung bestimmt es die Richtung. Wenn der Preis über die EMA geht, wird ein BUY-Signal generiert; wenn der Preis unter die EMA geht, wird ein SELL-Signal generiert.
Die Strategie kann die umgekehrte Eröffnungsposition beschränken, um die Anzahl der Trades zu kontrollieren.
Die Stop-Loss-Bedingungen werden auf der Grundlage von 3 Optionen festgelegt: Fixed Stop-Loss, ATR Stop-Loss, Price Swing Stop-Loss.
Trailing-Stop kann aktiviert werden, um mehr Gewinne zu erzielen, standardmäßig deaktiviert.

Analyse der Vorteile

Die Zufälligkeit der Modulo-Arithmetik vermeidet die Auswirkungen von Kursschwankungen, kombiniert mit dem Trendbeurteil von gleitenden Durchschnitten kann sie ungültige Signale effektiv filtern.
Die EMA als Metrik für den mittelfristigen bis langfristigen Trend in Kombination mit kurzfristigen Modulo-Signalen ermöglicht eine mehrschichtige Überprüfung und vermeidet falsche Signale.
Hochflexible anpassbare Parameter, die für verschiedene Märkte angepasst werden können, um optimale Parameterkombinationen zu finden.
Integriert mehrere Stop-Loss-Methoden, um Risiken zu kontrollieren.
Unterstützt direkte Umkehröffnung von Positionen für nahtlose Richtungswechsel. Kann auch deaktiviert werden, um die Anzahl der Trades zu reduzieren.

Risikoanalyse

Die falsche Einstellung der Parameter kann zu viele Handelssignale erzeugen, was die Handelsfrequenz und die Kosten für Ausrutscher erhöht.
EMA als einziger Trendbeurteilungsindikator kann sich verzögern, da Preisschwankungen fehlen.
Die festgelegte Stop-Loss-Methode kann zu mechanisch sein und sich nicht an Marktschwankungen anpassen.
Die direkte Umkehröffnung erhöht die Häufigkeit der Positionsanpassungen und erhöht die Kosten und Risiken.

Optimierungsrichtlinien

Versuche verschiedene gleitende Durchschnitte anstelle von EMA oder kombiniere EMA mit anderen MAs, um zu sehen, ob die Rentabilitätsrate verbessert werden kann.
Versuchen Sie, den Modulfilter mit anderen Strategien wie Bollinger-Bändern, Kerzenmustern usw. zu kombinieren, um stabilere Filter zu erstellen.
Erforschung adaptiver Stop-Loss-Methoden auf der Grundlage von Marktvolatilitätsniveaus zur Anpassung der Stop-Distanz.
Festlegen von Grenzen für die Anzahl der Geschäfte oder Gewinn-/Verlustschwellen, um die Häufigkeit der direkten Umkehröffnung zu begrenzen.

Schlussfolgerung

Diese Strategie kombiniert effektiv die Zufälligkeit von Modulo-Operationen und das Trendbeurteilen von gleitenden Durchschnitten durch flexible Parameteranpassungen, die auf verschiedene Marktumgebungen zugeschnitten sind, was zu zuverlässigen Handelssignalen führt. Sie integriert auch verschiedene Stop-Mechanismen zur Risikokontrolle sowie Gewinn- und Trailing-Stops, um Gewinne zu erzielen. Die Gesamtlogik ist klar und leicht zu verstehen und zu ändern. Sie hat ein immenses praktisches Potenzial, das weiteren Tests und Optimierungen wert ist.

/*backtest
start: 2023-11-12 00:00:00
end: 2023-12-12 00:00:00
period: 1h
basePeriod: 15m
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/
// © tweakerID

// To understand this strategy first we need to look into the Modulo (%) operator. The modulo returns the remainder numerator 
// of a division's quotient (the result). If we do 5 / 3, we get 1 and 2/3 as a result, where the remainder is 2 (two thirds, in this case). This can be
// used for many things, for example to determine when a number divides evenly into another number. If we divide 3/3, our result is 1,
// with no remainder numerator, hence our modulo result is 0. In this strategy, we compare a given number (divisor, user defined) with the
// the closing price of every candle (dividend, modifiable from the inputs panel) to determine if the result between their division is an even number. 
// If the answer is true, we have an entry signal. If this signal occurs below the EMA (length is defined by the user) we go short and
// viceversa for longs. This logic can be reversed. In this case, the modulo works as a random-like filter for a moving average strategy
// that usually struggles when the market is ranging.

//@version=4

//@version=4
strategy("Modulo Logic + EMA Strat", 
     overlay=true, 
     default_qty_type=strategy.percent_of_equity, 
     default_qty_value=100, 
     initial_capital=10000, 
     commission_value=0.04, 
     calc_on_every_tick=false, 
     slippage=0)

direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))

/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")  

a=input(close, title="Dividend")
b=input(4, title="Divisor")
usemod=input(true, title="Use Modulo Logic")
MALen=input(70, title="EMA Length")

/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")  

// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
i_SLType=input(defval="ATR Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=3, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(4, step=.1, title="ATR Multiple")
i_TPRRR = input(1, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(false, title="Trailing Stop")

// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1] 
 or strategy.position_size < strategy.position_size[1]

// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na 
entry_HH_price = strategy.position_size < 0 ? HH_price : na 
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR

// ATR Stop
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na 
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na 
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR


// Strategy Stop

float LongStop = na
float ShortStop = na
float StratTP = na
float StratSTP = na

/////////////////////// STRATEGY LOGIC /////////////////////////////////////////

modulo=a%b
evennumber=modulo==0
MA=ema(close, MALen)
plot(MA)

BUY=usemod ? evennumber and close > MA : close > MA
SELL=usemod ? evennumber and close < MA : close < MA

//Trading Inputs
DPR=input(true, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")

// Entries
if reverse
    if not DPR
        strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
    else     
        strategy.entry("long", strategy.long, when=SELL)
        strategy.entry("short", strategy.short, when=BUY)
else
    if not DPR 
        strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
        strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
    else
        strategy.entry("long", strategy.long, when=BUY)
        strategy.entry("short", strategy.short, when=SELL)


SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP

//TrailingStop
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
 -strategy.position_avg_price
trailOffset     = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
    tstop := high- trailOffset - dif
    if tstop<tstop[1]
        tstop:=tstop[1]
else
    tstop := na
StrailOffset     = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0 
 and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
    Ststop := low+ StrailOffset + Sdif
    if Ststop>Ststop[1]
        Ststop:=Ststop[1]
else
    Ststop := na

strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL, when=i_SL)

/////////////////////// PLOTS //////////////////////////////////////////////////

plot(i_SL and strategy.position_size > 0 and not TS ? SL : i_SL and strategy.position_size > 0 and TS ? tstop : na , title='SL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size < 0 and not TS ? SSL : i_SL and strategy.position_size < 0 and TS ? Ststop : na , title='SSL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(i_SL and strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar, 
 color=color.green, title="Bullish Setup", size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar, 
 color=color.red, title="Bearish Setup", size=size.auto)

Mehr