Stratégie de croisement de moyenne mobile à angle de tendance
ChaoZhang
Aperçu
Cette stratégie consiste à calculer l’angle de la pente de la ligne moyenne pour déterminer la direction de la tendance, en combinaison avec un indicateur de la variation du taux de change des prix. Son essence est de déterminer la tendance des prix à l’aide de l’angle de la pente de la ligne moyenne, ainsi que la stratégie de suivi de la tendance de l’indicateur de la variation du taux de change des prix.
Principe de stratégie
La stratégie est basée sur les critères suivants:
L’angle de la moyenne: pour déterminer la direction de la tendance des prix, on calcule l’angle de la pente de la moyenne de Jurik et de la moyenne mobile de l’indice. Un angle supérieur à 0 est une tendance à la hausse et inférieur à 0 est une tendance à la baisse.
Taux de variation des prix: calculer le taux de variation des prix de clôture des 12 dernières lignes K et filtrer les signaux inefficaces par la volatilité.
Faire plus lorsque l’angle de la ligne moyenne est vers le haut (plus de 0) et que le taux de variation des prix est satisfaisant; faire moins lorsque l’angle de la ligne moyenne est vers le bas (moins de 0) et que le taux de variation des prix est satisfaisant.
Plus précisément, la stratégie commence par calculer l’angle de pente de la moyenne de Jurik et de l’EMA. Ensuite, elle calcule l’indicateur du taux de variation des prix, qui est utilisé pour filtrer les périodes de liquidation. Elle génère un signal de transaction lorsque l’angle de la moyenne indique une tendance et que le taux de variation des prix est conforme.
Analyse des avantages
Cette stratégie présente les avantages suivants:
Le taux de réussite est très élevé et il est très fiable de déterminer les tendances en utilisant la pente moyenne.
L’indicateur du taux de variation des prix permet de filtrer efficacement les fluctuations et d’éviter les transactions inefficaces.
La moyenne de Jurik réagit rapidement à la rupture, tandis que l’EMA fournit un jugement de tendance stable, les deux se complétant.
Le trading à deux vitesses, à court et à long terme, permet d’attraper des gains plus importants dans des conditions de tendance.
Analyse des risques
Cette stratégie comporte aussi des risques:
Il est possible de réduire ce risque en utilisant des paramètres d’optimisation.
Les signaux homogènes peuvent être fréquemment commutés lors de l’entrée dans le comptage, ce qui génère trop de transactions inutiles. Des conditions de filtrage supplémentaires peuvent être ajoutées pour réduire les transactions invalides.
Le stop loss peut être dépassé en cas d’événement imprévu qui entraîne une hausse du prix et le point de stop loss peut être relâché de manière appropriée.
Direction d’optimisation
Cette stratégie peut être optimisée dans les domaines suivants:
Optimiser les paramètres de la moyenne, trouver la combinaison optimale de paramètres et améliorer la stabilité de la stratégie.
Augmentation des conditions de filtrage telles que la volatilité et le volume des transactions, afin de réduire encore plus les transactions non valides.
Les points de rupture sont déterminés par un ensemble d’indicateurs qui permettent d’évaluer les points de rupture de manière plus intelligente.
Le développement d’algorithmes de trading adaptés à la taille des transactions, permettant une plus grande stabilité des bénéfices.
Résumer
Cette stratégie est une stratégie de suivi de tendance très pratique dans l’ensemble. Elle utilise une inclinaison linéaire moyenne pour déterminer la tendance de manière très fiable, et l’indicateur de taux de variation des prix permet de filtrer efficacement les signaux inefficaces.
/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Based on ma angles code by Duyck which also uses Everget Jurik MA calulation and angle calculation by KyJ
strategy("Trend Angle BF", overlay=false)
/////////////// Time Frame ///////////////
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
src=input(ohlc4,title="source")
// definition of "Jurik Moving Average", by Everget
jma(_src,_length,_phase,_power) =>
phaseRatio = _phase < -100 ? 0.5 : _phase > 100 ? 2.5 : _phase / 100 + 1.5
beta = 0.45 * (_length - 1) / (0.45 * (_length - 1) + 2)
alpha = pow(beta, _power)
jma = 0.0
e0 = 0.0
e0 := (1 - alpha) * _src + alpha * nz(e0[1])
e1 = 0.0
e1 := (_src - e0) * (1 - beta) + beta * nz(e1[1])
e2 = 0.0
e2 := (e0 + phaseRatio * e1 - nz(jma[1])) * pow(1 - alpha, 2) + pow(alpha, 2) * nz(e2[1])
jma := e2 + nz(jma[1])
//// //// Determine Angle by KyJ //// ////
angle(_src) =>
rad2degree=180/3.14159265359 //pi
ang=rad2degree*atan((_src[0] - _src[1])/atr(14))
jma_line=jma(src,10,50,1)
ma=ema(src,input(56))
jma_slope=angle(jma_line)
ma_slope=angle(ma)
///////////// Rate Of Change /////////////
source = close
roclength = input(12, minval=1)
pcntChange = input(2, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = ma_slope>=0 and isMoving()
short = ma_slope<=0 and isMoving()
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])
sl_inp = input(2.0, title='Stop Loss %') / 100
tp_inp = input(900.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[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
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
///////////// Plotting /////////////
hline(0, title='Zero line', color=color.purple, linewidth=1)
plot(ma_slope,title="ma slope", linewidth=2,color=ma_slope>=0?color.lime:color.red)
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)