Stratégie de filtrage d'analyse de correction d'index

Date de création: 2023-12-13 15:55:07 Dernière modification: 2023-12-13 15:55:07

Copier: 0 Nombre de clics: 637

ChaoZhang

Suivre Messages privés

Suivre

1621

Abonnés

Stratégie de filtrage d’analyse de correction d’index

Aperçu

La stratégie utilise une combinaison d’opérations de modélisation et de moyennes mobiles indicielles pour réaliser un filtre de tendance fortement aléatoire pour déterminer la direction de la position. La stratégie calcule d’abord si le prix est divisé par le résultat d’un chiffre défini par 0, et si c’est 0, un signal de transaction apparaît. Ce signal est négatif si l’indicateur est inférieur à la moyenne mobile de l’indicateur; plus si l’indicateur est supérieur à la moyenne mobile de l’indicateur.

Principe de stratégie

La valeur de l’entrée de prix a est la valeur de clôture de la clôture, qui peut être modifiée; la valeur de la division b est 4, qui peut être modifiée.
Calculer le résidu de a divisé par b modulo pour déterminer si le résidu est égal à 0.
L’indicateur est défini sur la longueur de la moyenne mobile MALen, avec 70 cycles par défaut, comme indicateur de jugement de la tendance à moyen et long terme des prix.
Lorsque le résidu modulo est égal à 0, le signal de transaction est égal, et la relation avec l’EMA détermine la direction. Lorsque le prix traverse la ligne EMA au-dessus, il génère un signal d’achat BUY; lorsque le prix traverse la ligne EMA en dessous, il génère un signal de vente SELL.
Les entrées de négociation entrent dans des positions de plus ou de moins selon la direction du signal. La stratégie peut limiter les positions de revers pour contrôler le nombre de transactions.
Les conditions d’arrêt sont réglées en fonction de trois modes d’arrêt: arrêt fixe, arrêt ATR et arrêt de la fourchette de fluctuation des prix. La condition d’arrêt est l’inverse de l’arrêt.
Vous pouvez choisir d’utiliser ou non le stop-loss mobile pour verrouiller plus de profits, par défaut.

Analyse des avantages

Le fonctionnement aléatoire du modèle évite d’être affecté par les fluctuations de prix et, en combinaison avec le jugement de tendance des moyennes mobiles, peut filtrer efficacement certains signaux inefficaces.
Les moyennes mobiles sont utilisées comme indicateur de tendance à moyen et long terme, en combinaison avec des signaux à court terme de modélisation, permettant une vérification à plusieurs niveaux et évitant les faux signaux.
Les paramètres personnalisables sont très flexibles et permettent d’ajuster les paramètres en fonction des différents marchés pour trouver la combinaison optimale.
La gestion des risques est assurée par l’intégration d’une multitude de méthodes de stop loss.
Il est possible d’ouvrir des positions directement à l’envers et de changer la direction de la position sans effort. Il est également possible de désactiver cette fonction pour réduire le nombre de transactions.

Analyse des risques

Une mauvaise configuration des paramètres peut entraîner une surproduction de signaux de transaction, une augmentation de la fréquence des transactions et des coûts de dérapage.
L’indicateur de la moyenne mobile est le seul indicateur de tendance, ce qui peut entraîner un retard et manquer le moment de la reprise des cours.
La méthode de stop-loss fixe peut être trop mécanique pour s’adapter aux fluctuations du marché.
L’ouverture de position directe à l’envers augmente la fréquence des ajustements de position, les coûts de transaction et les risques.

Direction d’optimisation

Il est possible de tester différents indicateurs de la ligne moyenne au lieu de l’EMA, ou de combiner l’EMA avec d’autres lignes moyennes pour voir si le taux de profit peut être amélioré.
On peut essayer de combiner les filtres de modélisation avec d’autres stratégies, telles que les bandes de Bryn, les formes de ligne K, etc., pour former un filtre plus stable.
Il est possible d’étudier les méthodes d’adaptation au stop loss, en ajustant la distance de stop loss en fonction de la volatilité du marché.
Il est possible de régler le nombre de transactions ou le seuil de pertes pour limiter le nombre d’ouvertures de position directes inverses.

Résumer

La stratégie est basée sur des opérations de modélisation qui permettent de combiner efficacement le filtrage aléatoire avec le jugement de la tendance des moyennes mobiles. La configuration des paramètres est flexible et peut être ajustée et optimisée en fonction des différentes conditions du marché, ce qui permet d’obtenir des signaux de négociation plus fiables.

Code source de la stratégie

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

Forums

PINE Language FAQ Summary MyLanguage Web3 About Us

Product

Robot Strategy Node Platforms Tickets

API

Syntax guide User guide Trading api Blockchain Indicator