Modulo logique avec stratégie de filtrage EMA

Auteur:ChaoZhang est là., Date: 2023-12-13 15h55,07
Les étiquettes:

Résumé

Cette stratégie combine les opérations arithmétiques modulo et les moyennes mobiles exponentielles pour créer un filtre de hasard fort pour déterminer la direction de la position. Elle calcule d'abord le reste du prix divisé par un nombre défini, et un signal de trading est généré si le reste est 0. Si ce signal est en dessous de la ligne EMA, allez court; si au-dessus, allez long. Cette stratégie intègre le hasard des opérations mathématiques et la tendance de jugement des indicateurs techniques, en utilisant la validation croisée entre les indicateurs de différents cycles pour filtrer efficacement une partie du bruit du marché.

La logique de la stratégie

Définir la valeur d'entrée de prix a comme fermé, modifiable; définir le diviseur b comme 4, modifiable.
Calculez le modulo du reste de a divisé par b, déterminez si le modulo est égal à 0.
Définir par défaut la longueur de l'EMA (MALen) à 70 périodes comme mesure de la tendance à moyen et à long terme.
Lorsque le modulo est égal à 0, un signal de trading est généré par un nombre pair. Combiné avec la relation EMA, il détermine la direction. Lorsque le prix dépasse la EMA, un signal BUY est généré; lorsque le prix dépasse la EMA, un signal SELL est généré.
Les entrées de négociation sont ouvertes longues ou courtes en fonction de la direction du signal.
Les conditions de stop loss sont définies en fonction de 3 options: stop loss fixe, ATR stop loss, prix swing stop loss.
Le trailing stop peut être activé pour verrouiller plus de profits, désactivé par défaut.

Analyse des avantages

Le hasard de l'arithmétique modulo évite les effets des fluctuations de prix, combiné avec le jugement de tendance des moyennes mobiles, il peut filtrer efficacement les signaux invalides.
L'EMA en tant que mesure de la tendance à moyen et long terme combinée à des signaux modulo à court terme permet une vérification multicouches et évite les faux signaux.
Paramètres personnalisables hautement flexibles, pouvant être ajustés pour différents marchés afin de trouver des combinaisons optimales de paramètres.
Il intègre plusieurs méthodes de stop loss pour contrôler les risques.
Prend en charge l'ouverture inverse directe des positions pour un changement de direction sans heurts.

Analyse des risques

Les paramètres incorrects peuvent générer trop de signaux de négociation, augmentant la fréquence des transactions et les coûts de glissement.
L'EMA comme seule mesure de jugement de tendance peut être retardée, manquant des moments d'inversion des prix.
La méthode de stop loss fixe peut être trop mécanique, incapable de s'adapter aux fluctuations du marché.
L'ouverture inverse directe augmente la fréquence des ajustements de position, ce qui augmente les coûts et les risques.

Directions d'optimisation

Testez différentes moyennes mobiles au lieu de l'EMA, ou combinez l'EMA avec d'autres MAs, pour voir si le taux de rentabilité peut être amélioré.
Essayez de combiner le filtre modulo avec d'autres stratégies comme les bandes de Bollinger, les modèles de bougies, etc. pour créer des filtres plus stables.
Rechercher des méthodes de stop loss adaptatives basées sur les niveaux de volatilité du marché pour ajuster la distance de stop.
Le montant de l'opération est calculé à partir de la valeur de l'opération.

Conclusion

Cette stratégie combine efficacement le hasard des opérations modulo et le jugement de tendance des moyennes mobiles grâce à des ajustements de paramètres flexibles adaptés à différents environnements de marché, résultant en des signaux de trading fiables. Elle intègre également divers mécanismes d'arrêt pour contrôler les risques ainsi que des arrêts de profit et de trailing pour verrouiller les bénéfices.

/*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)

Plus de

2019 FMZ - Tous les droits réservés