Les ressources ont été chargées... Je charge...

Stratégie de négociation croisée sur plusieurs moyennes mobiles

Auteur:ChaoZhang est là., Date: 2023-12-06 à 17h10
Les étiquettes:

img

Vue d'ensemble de la stratégie

Cette stratégie génère des signaux de négociation basés sur plusieurs indicateurs de moyenne mobile. Il surveille simultanément les moyennes mobiles à court, moyen et long terme, et génère des signaux de négociation en fonction de leurs situations de croisement pour déterminer la direction de la tendance.

Nom de la stratégie

Stratégie de croisement des moyennes mobiles multiples

La logique de la stratégie

Cette stratégie utilise 3 moyennes mobiles avec des périodes différentes, y compris des lignes de 7 jours, 13 jours et 21 jours.

  1. Lorsque l'AM à court terme de 7 jours franchit à la hausse l'AM à moyen terme de 13 jours, tandis que l'AM à long terme de 21 jours est en hausse, un signal long est généré.
  2. Lorsque l'AM à court terme de 7 jours dépasse l'AM à moyen terme de 13 jours vers le bas, tandis que l'AM à long terme de 21 jours est en baisse, un signal court est généré.

En combinant des moyennes mobiles sur différentes périodes, la stratégie permet de juger plus précisément des tendances du marché et d'éviter les faux trades.

Les avantages

  1. L'utilisation de plusieurs lignes MA permet de mieux déterminer les mouvements du marché et d'éviter d'être induit en erreur par de fausses ruptures ou des fluctuations à court terme du marché.
  2. Les signaux ne sont générés que lorsque la tendance est claire, réduisant ainsi les transactions inutiles et les coûts de transaction.
  3. Paramètres flexibles - les périodes des AP peuvent être ajustées en fonction des préférences personnelles pour s'adapter à différents produits et environnements de marché.

Les risques

  1. Des signaux erronés fréquents peuvent se produire sur un marché volatile.
  2. En tant qu'indicateurs de tendance, les MAs ne sont pas en mesure de localiser avec précision les points tournants.
  3. Le signal retardé par les croisements MA peut manquer une partie des bénéfices.
  4. Les risques peuvent être réduits par l'introduction d'autres indicateurs techniques pour la validation du signal et l'optimisation des paramètres de l'AM.

Directions d'optimisation

  1. Envisagez d'inclure des indicateurs de volatilité pour mesurer la force de la tendance et éviter de négocier sur des marchés instables.
  2. Essayez d'appliquer des modèles d'apprentissage automatique pour optimiser automatiquement les paramètres MA.
  3. Ajoutez des stratégies de stop loss pour réduire les pertes à temps lorsque les retraits augmentent.
  4. Utilisez des ordres de limite lorsque le croisement MA se produit pour réduire le glissement.

Conclusion

Cette stratégie combine les MAs à court, moyen et long terme pour déterminer la tendance du marché en fonction de leurs relations croisées, ce qui en fait une stratégie de suivi de tendance relativement stable et efficace.


/*backtest
start: 2022-11-29 00:00:00
end: 2023-12-05 00:00:00
period: 1d
basePeriod: 1h
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/
// © Crypto-Oli

//@version=4
strategy("CryptOli 3 MAs long/short Backtest", initial_capital=5000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, overlay=true)

// this is an educational Script - basicly its very simple - you can see how minimal changes impact results, thats why i posted it
// Credits to Quantnomad to publish tons of free educational script
// this Script is based on https://www.tradingview.com/script/0NgUadGr-Ultimate-MA-Cross-Indicator/ Quantnomads Ultimate MA Indicator 
// HA - Option for calcucaltion based on HA-Candles (very famous recently)
// Source Input - Option (Candletype for calculation, close, ohlc4 ect.) --- there are huge differences --- try it by your own

////////////////////////////////////////////////////////////////////////////////
// BACKTESTING RANGE

// From Date Inputs
fromDay = input(defval=1, title="From Day", minval=1, maxval=31)
fromMonth = input(defval=1, title="From Month", minval=1, maxval=12)
fromYear = input(defval=2015, title="From Year", minval=1970)

// To Date Inputs
toDay = input(defval=1, title="To Day", minval=1, maxval=31)
toMonth = input(defval=1, title="To Month", minval=1, maxval=12)
toYear = input(defval=2030, title="To Year", minval=1970)

// Calculate start/end date and time condition
startDate = timestamp(fromYear, fromMonth, fromDay, 00, 00)
finishDate = timestamp(toYear, toMonth, toDay, 00, 00)
time_cond = time >= startDate and time <= finishDate

////////////////////////////////////////////////////////////////////////////////

h = input(false, title = "Signals from Heikin Ashi Candles")

ma_type      = input(title = "MA Type",         type = input.string,  defval = "SMMA", options = ['SMA', 'EMA', 'WMA', 'VWMA', 'HMA', 'SMMA', 'DEMA'])
src = input(ohlc4)

short_ma_len = input(title = "Short MA Length", type = input.integer, defval = 7,     minval = 1)
short_ma_src = h ? security(heikinashi(syminfo.tickerid), timeframe.period, src, lookahead = false) : close
middle_ma_len  = input(title = "Middle MA Length",  type = input.integer, defval = 13,    minval = 2)
middle_ma_src = h ? security(heikinashi(syminfo.tickerid), timeframe.period, src, lookahead = false) : close
long_ma_len  = input(title = "Long MA Length",  type = input.integer, defval = 21,    minval = 2)
long_ma_src = h ? security(heikinashi(syminfo.tickerid), timeframe.period, src, lookahead = false) : close


tick_round(x) => 
    round(x / syminfo.mintick) * syminfo.mintick

// Set initial values to 0
short_ma = 0.0
middle_ma = 0.0
long_ma  = 0.0

// Simple Moving Average (SMA)
if ma_type == 'SMA' 
    short_ma := sma(short_ma_src, short_ma_len)
    middle_ma := sma(middle_ma_src, middle_ma_len)
    long_ma  := sma(long_ma_src,  long_ma_len)

// Exponential Moving Average (EMA)
if ma_type == 'EMA'
    short_ma := ema(short_ma_src, short_ma_len)
    middle_ma := ema(middle_ma_src, middle_ma_len)
    long_ma  := ema(long_ma_src,  long_ma_len)

// Weighted Moving Average (WMA)
if ma_type == 'WMA'
    short_ma := wma(short_ma_src, short_ma_len)
    middle_ma := wma(middle_ma_src, middle_ma_len)
    long_ma  := wma(long_ma_src,  long_ma_len)

// Hull Moving Average (HMA)
if ma_type == 'HMA'
    short_ma := wma(2*wma(short_ma_src, short_ma_len/2)-wma(short_ma_src, short_ma_len), round(sqrt(short_ma_len)))
    middle_ma := wma(2*wma(middle_ma_src, middle_ma_len/2)-wma(middle_ma_src, middle_ma_len), round(sqrt(middle_ma_len)))
    long_ma  := wma(2*wma(long_ma_src,  long_ma_len /2)-wma(long_ma_src,  long_ma_len),  round(sqrt(long_ma_len)))

// Volume-weighted Moving Average (VWMA)
if ma_type == 'VWMA'
    short_ma := vwma(short_ma_src, short_ma_len)
    middle_ma := vwma(middle_ma_src, middle_ma_len)
    long_ma  := vwma(long_ma_src,  long_ma_len)


// Smoothed Moving Average (SMMA)    
if ma_type == 'SMMA'
    short_ma := na(short_ma[1]) ? sma(short_ma_src, short_ma_len) : (short_ma[1] * (short_ma_len - 1) + short_ma_src) / short_ma_len
    middle_ma := na(middle_ma[1]) ? sma(middle_ma_src, middle_ma_len) : (middle_ma[1] * (middle_ma_len - 1) + middle_ma_src) / middle_ma_len
    long_ma  := na(long_ma[1])  ? sma(long_ma_src,  long_ma_len)  : (long_ma[1]  * (long_ma_len  - 1) + long_ma_src)  / long_ma_len

// Double Exponential Moving Average (DEMA)
if ma_type == 'DEMA'
    e1_short = ema(short_ma_src, short_ma_len)
    e1_middle = ema(middle_ma_src, middle_ma_len)
    e1_long  = ema(long_ma_src,  long_ma_len)
    
    short_ma := 2 * e1_short - ema(e1_short, short_ma_len)
    middle_ma := 2 * e1_middle - ema(e1_middle, middle_ma_len)
    long_ma  := 2 * e1_long  - ema(e1_long,  long_ma_len)

// Plot MAs
plot(short_ma, color = color.green,   linewidth = 1)
plot(middle_ma, color = color.yellow,   linewidth = 1)
plot(long_ma,  color = color.red, linewidth = 1)

if close>long_ma and short_ma>middle_ma and time_cond
    strategy.entry("Long", strategy.long)


if close<long_ma and short_ma<middle_ma and time_cond
    strategy.entry("Short", strategy.short)


Plus de