Viewing posts categorised under: MQL

Trois axes majeurs pour ce vendredi !

Bastien
0 comments
MQL

Nous diviserons cette dernière séance de la semaine en trois axes centraux. A nouveau, nous insisterons sur le renforcement des acquis techniques présentés tout au long de la semaine sur l’indice allemand. Depuis mardi après-midi, le DAX concentre en effet l’essentiel de ses cotations au sein du range 10 630 / 10 715 points. En ce début de matinée, la volatilité semble très calme et nous tablons d’une manière plus large sur un vendredi particulièrement tranquille. Nous ne travaillerons donc qu’à très court terme aujourd’hui, en Scalping, sur l’indice allemand. Décryptage.

Pas d’overnight ce week-end !

Ce renforcement des acquis techniques est une aubaine pour le Scalping. Néanmoins, nous rehaussons notre frontière technique compte tenu du peu de volatilité de ce début de matinée. Toute cotation supérieure à 10 670 points pour ce vendredi nous incitera à renforcer à la hausse nos différentes opérations et à respecter notre préférence psychologique pour ces prochaines heures. Et ce, tout en continuant de viser les 10 715 voire les 10 780 en cas de rupture. Niveau extrême à considérer pour le début de semaine prochaine en cas de maintien de la pression haussière : les 10 860 points. Cependant, nous opterons pour une approche conservatrice aujourd’hui en clôturant toutes nos opérations avant 22h.

En effet, nous déconseillons très fortement de maintenir ouvertes de telles opérations (sur indices occidentaux) en overnight, le temps du week-end, compte tenu de l’actualité chargée et de la diffusion du PIB japonais pour le deuxième trimestre 2016 dans le courant de la nuit de dimanche à lundi. En parallèle, nous surveillerons tout au long de cette dernière séance les valeurs dévoilées à 11h00 et à 14h30, respectivement pour le PIB de la zone euro au Q2 et pour les ventes au détail américaines (juillet). Ces publications seront au centre de nos attentes pour maintenir la pression haussière sur l’indice allemand, via nos habituelles opérations de 5 points d’amplitude.

A l’approche de la fin de la trêve estivale, les tensions semblent de plus en plus palpables. Pour autant, nous attendrons le retour des volumes conséquents pour se réapproprier le contenu du calendrier économique. Et ce, en optant très certainement à la rentrée pour un biais baissier sur les grands indices occidentaux et haussier pour l’or, le Bund et le Vix (S&P500).

Retrouvez nos dernières analyses forex :

Trader plus facilement avec VOTRE robot de trading / algorithme de trading !

Read more

MQL4 erreurs communes et comment les éviter

Bastien
0 comments
MQL

Introduction

D’anciens robots de trading, indicateurs et scripts glanés sur Internet peuvent vous retourner de nombreuses erreurs à la compilation. Cet article va vous permettre de les comprendre.

Pour éviter un arrêt critique du robot de trading, les anciens compilateurs géraient de nombreuses erreurs dans l’environnement d’exécution (runtime). Par exemple, la division par zéro ou un accès incorrect à un tableau (out of range) sont des erreurs critiques, qui généralement conduisent au plantage de l’application. Ces erreurs ne se produisent que dans certains cas pour certaines valeurs des variables. Cet article va vous aider à gérer ces erreurs.

Le nouveau compilateur peut détecter les sources réelles ou potentielles des erreurs et améliorer la qualité du code.

Dans cet article, nous discutons des erreurs possibles lors de la compilation des anciens algorithmes de trading et les moyens de les réparer.

En voici le sommaire :

  1. Erreurs à la compilation
  2. Erreurs à l’éxécution
  3. Warnings à la compilation

 

1 Erreurs à la compilation

Si un code de programmation contient des erreurs, il ne peut pas être compilé.

Pour contrôler entièrement toutes les erreurs, il est recommandé d’utiliser le mode de compilation stricte, qui est fixé par la directive suivante :

Ce mode simplifie considérablement le dépannage.

 

1.1. Utilisation d’un mot réservé

Si le nom d’une variable ou d’une fonction coïncide avec un des mots réservés

le compilateur retourne un message d’erreur :

Figure 1. Errors "unexpected token" and "name expected"

Figure 1. Erreurs « unexpected token » et « name expected »

Pour corriger cette erreur, vous devez utiliser utiliser un nom différent.

1.2. Les caractères spéciaux dans les noms de variables et fonctions

Si les noms des variables ou des fonctions contiennent des caractères spéciaux ($, @, point) :

1.3. Mauvaise utilisation de l’opérateur SWITCH

Dans l’ancienne version du compilateur, vous pouviez utiliser n’importe quelle valeur dans les expressions et les constantes de l’opérateur SWITCH :

Dans le nouveau compilateur, les constantes et les expressions de l’opérateur SWITCH doivent être des entiers, donc des erreurs se produisent lorsque vous essayez d’utiliser d’autres types :

Figure 3. Errors "illegal switch expression type" and "constant expression is not integral"

Figure 3. Erreurs « illegal switch expression type » et « constant expression is not integral »

Dans de tels cas, vous pouvez utiliser la comparaison explicite des valeurs numériques :

1.4. Les fonctions retournant une valeur

Toutes les fonctions, sauf celle de type void doivent retourner la valeur du type déclaré. Par exemple :

En mode de compilation stricte une erreur se produit :

Figure 4. Error "not all control paths return a value"

Figure 4. Erreur »not all control paths return a value »

En mode de compilation par défaut, le compilateur retourne un avertissement :

Figure 5. Warning "not all control paths return a value"

Figure 5. Avertissement « not all control paths return a value »

Si la valeur de retour de la fonction ne correspond pas à celui déclaré :

une erreur est détectée lors de la compilation stricte :

Figure 6. Error "function must return a value"

Figure 6. Erreur « function must return a value »

En mode de compilation par défaut, le compilateur retourne un avertissement :

Figure 7. Warning 'return - function must return a value"

Figure 7. Avertissement « return – function must return a value »

 

Pour corriger ces erreurs, ajoutez l’opérateur return avec la valeur de retour du type correspondant au prototype de la fonction.

1.5. Passer un tableau en paramètres d’une fonction

Lorqu’ils sont utilisés en tant qu’argument de fonction, les tableaux sont passés uniquement par référence :

En mode de compilation strict, ce code provoquera une erreur :

Figure 8. Compiler error "arrays passed by reference only"

Figure 8. Erreur à la compilation « arrays passed by reference only »

En mode de compilation par défaut, le compilateur retourne un avertissement :

Figure 9. Compiler warning "arrays passed by reference only"

Figure 9. Avertissement à la compilation « arrays passed by reference only »

Pour corriger cette erreur, vous devez préciser explicitement que le tableau est passé par référence en ajoutant le préfixe & avant le nom du tableau :

Il convient de noter que les tableaux maintenant constants (Time [], Open [], High [], Low [], Close [], Volume []) ne peuvent pas être passés par référence. Par exemple, l’appel suivant :

quel que soit le mode de compilation elle conduit à une erreur :

Figure 10. Error 'Open' - constant variable cannot be passed as reference

Figure 10. Erreur ‘Open’ – constant variable cannot be passed as reference

Pour éviter ces erreurs, vous pouvez copier les données requises à partir du tableau constant :

2 Erreurs à l’éxécution

Les erreurs qui se produisent pendant l’exécution du code d’un robot de trading, un indicateur ou un script sont appelées erreurs à l’exécution (runtime errors). Ces erreurs dépendent généralement de l’état du programme et sont associées à des valeurs incorrectes de variables.

Par exemple, si une variable est utilisée comme un indice d’éléments d’un tableau, une valeur négative va inévitablement conduire à une erreur « array  out of range » (tableau hors de portée).

2.1. Array out of range

Cette erreur se produit souvent dans les indicateurs lors de l’accès aux buffers des indicateurs. La fonction IndicatorCounted () renvoie le nombre de barres inchangés depuis le dernier appel à l’indicateur. Les valeurs des indicateurs sur les barres précédemment calculées n’ont pas besoin d’être recalculés, donc pour des calculs plus rapides vous avez seulement besoin de traiter les dernières barres.

La plupart des indicateurs qui utilisent cette méthode d’optimisation de calcul ressemblent à ceci :

Souvent le cas de counted_bars == 0 est traitée de manière incorrecte (la position limite initiale doit être réduite par la valeur égale à 1 + l’indice maximal par rapport à la variable de boucle).

Aussi, rappelez-vous que, au moment d’exécuter la fonction Start(), nous pouvons accéder aux éléments des buffers des indicateurs de 0 à Bars () -1. Si vous avez besoin de travailler avec des tableaux qui ne sont pas des buffers d’indicateurs, augmentez leur taille en utilisant la fonction ArrayResize() en fonction de la taille actuelle des buffers d’indicateurs. L’indice maximal de l’élément à traiter peut également être obtenu en appelant ArraySize() avec l’un des buffers utilisés comme argument.

2.2. Zero divide

L’erreur « zero divide » se produit lorsque le programme divise par 0 un autre nombre :

Lorsque vous exécutez ce script, un message d’erreur apparaît dans l’onglet Experts et le programme s’arrête :

Figure 11. Error message "zero divide"

Figure 11. Erreur « zero divide »

Habituellement, cette erreur se produit lorsque la valeur du diviseur est déterminée par une ou des variable(s) externe(s). Par exemple, l’utilisation la marge utilisée  peut conduire à cette erreur si aucun ordre n’est ouvert puisque celle-ci sera égale à 0. Un autre exemple : si les données analysées sont lues à partir d’un fichier, nous ne pouvons pas garantir un fonctionnement correct si le fichier n’est pas accessible. Donc, il est important de connaitre ces cas et de les traiter correctement.

La manière la plus simple consiste à vérifier le diviseur avant l’opération de division et de remonter une erreur :

Cela ne provoque pas d’erreur critique, un message est affiché dans le journal tout en suspendant l’exécution de l’algorithme jusqu’au prochain tick pour un robot de trading et un indicateur ou définitivement pour un script :

Figure 12. Incorrect divider message

Figure 12. Message d’erreur après détection d’un mauvais diviseur

2.3. Utilisation de 0 en lieu et place de NULL

Dans l’ancienne version du compilateur 0 (zéro) pouvait être utilisé comme un argument dans les fonctions de l’API metaquotes demandant la spécification d’un instrument financier.

Par exemple, la valeur de l’indicateur technique Moving Average pour le symbole actuel pouvait être appelé comme suit :

Dans le nouveau compilateur vous devez spécifier explicitement NULL pour spécifier l’instrument actuel :

En outre, l’instrument financier actuel et la période peuvent être spécifiés en utilisant les fonctions Symbol() et Period().

2.4. Chaines de caractères Unicode et leur utilisation dans les DLL externes

Les chaînes sont représentées actuellement comme une séquence de caractères Unicode.

Rappelez-vous ceci et utilisez les fonctions Windows appropriés. Par exemple, lorsque vous utilisez la bibliothèque wininet.dll à la place d’apeller InternetOpenA() et InternetOpenUrlA(), vous devez appeler InternetOpenW() et InternetOpenUrlW().

La structure interne des chaînes a changé en MQL4 (maintenant il prend 12 octets) et la structure MqlString doit être utilisé lors du passage des chaînes de DLL :

2.5. Partage de fichier

Dans la nouvelle version de MQL4, FILE_SHARE_WRITE et FILE_SHARE_READ, des flags doivent être explicitement spécifiés pour l’utilisation partagée lors de l’ouverture des fichiers.

Si les flags sont absents, le fichier est ouvert en mode exclusif et ne peut pas être ouvert par quelqu’un tant qu’il n’est pas fermé.

Par exemple, lorsque vous travaillez avec des graphiques hors ligne, des flags de partage doivent être explicitement spécifiés :

Pour plus de détails lisez Offline Charts in the New MQL4 (Graphiques Hors Ligne dans le Nouveau MQL4)

2.6. Conversion du type Datetime

La conversion du datetime à une chaîne de caractère dépend maintenant du mode de compilation :

3 Warnings à la compilation

Les warnings du compilateur sont de type informatif et ne sont pas des messages d’erreur, par contre ils indiquent les sources possibles d’erreurs.

Un code clair ne doit pas contenir de warnings.

3.1. Les noms de variable globales et locales coincident

Si les variables sur les niveau global et local ont des noms similaires :

le compilateur affiche un avertissement indiquant le numéro de la ligne sur laquelle la variable globale est déclarée :

Figure 13. Warning "declaration of '%' hides global declaration at line %"

Figure 13. Warning « declaration of ‘%’ hides global declaration at line % »

Pour supprimer ces avertissements, corrigez les noms des variables globales.

3.2. Conversion implicite

Le nouveau compilateur possède une nouvelle méthode de conversion.

En mode de compilation strict, le compilateur affiche des avertissements de discordance de types :

Figure 14. Warnings "possible loss of data due to type conversion" and "implicit conversion from 'number' to 'string'

Figure 14. Warnings « possible loss of data due to type conversion » et « implicit conversion from ‘number’ to ‘string' »

Dans cet exemple, le compilateur met en garde contre la perte possible de précision pour les différents types de données assignées et la conversion implicite d’un int en chaîne de caractère.

Pour corriger ce warning dans vos robots de trading :

3.3. Variable inutilisée

La présence des variables qui ne sont pas utilisées dans le code de programmation (entités superflues) ne sont pas une bonne habitude.

Un warning de ces variables est affiché quel que soit le mode de compilation :

Figure 15. Warning "variable '%' not used'

Figure 15. Warning « variable ‘%’ not used’

Pour résoudre ce problème, supprimez les variables inutilisées de votre code.

 

Conclusion

L’article décrit les problèmes courants qui peuvent se produire lors de la compilation d’anciens robots de trading, indicateurs ou scripts qui contiennent des erreurs.

Dans tous les cas, il est recommandé d’utiliser le mode de compilation strict pour le débogage de l’algorithme de trading.

 

 

Traduit de COMMON ERRORS IN MQL4 PROGRAMS AND HOW TO AVOID THEM

 

Read more

Robot de trading gratuit basé sur Engulfing pattern

Bastien
0 comments
MQL

Introduction

Tous les traders se tournent à un moment donnée vers le price action. Ce n’est évidemment pas une simple technique d’analyse des cours, mais un système permettant d’éavluer statistiquement le futur mouvement du prix. Dans cet article nous analysons le motif d’enveloppement (Engulfing pattern) en créant un robot de trading gratuit pertinent qui utilise cette stratégie.

Règle de la stratégie « Engulfing pattern »

La détection

La philosophie de ce pattern est de localiser une bougie qui couvre complètement le corps de la bougie qui la précède. On peut également élargir cette définition en ajoutant l’enveloppement des ombres.

Il y a donc deux types de bougies enveloppantes :

  • BUOVB — Bullish Outside Vertical Bar (bougie enveloppante haussière)
  • BEOVB — Bearish Outside Vertical Bar (bougie enveloppante baissière)

 

pattern sur chart

Rentrons dans le détail de chacune des configurations :

  • BUEVB : Le graphique ci-dessus nous montre que le plus haut de la bougie baissière enveloppante est au-dessus du plus haut de la bougie précédente. Inversement pour les plus bas.
  • BUOVB : Le graphique ci-dessus nous montre que le plus haut de la bougie haussière enveloppante est au-dessus du plus haut de la bougie précédente. Inversement pour les plus bas.

pattern

Les règles

  1. Nous utiliserons uniquement des TF élevés : H4, D1
  2. Pour plus de précisions et moins de faux signaux, nous devrions nous appuyer sur les supports/résistances, niveaux de Fibonacci et les autres patterns
  3. L’utilisation d’ordre pending est recommandé pour éviter une entrée prématurée sur le marché
  4. Les signaux seront ignorés dans le cas d’une faible volatilité

Les points d’entrées

BUOVB

BUOVB

Dans notre exemple nous nous baserons sur le graphique ci-dessus :

  1. Le prix d’entrée de l’ordre BUY STOP se situera juste au-dessus du plus haut de la bougie enveloppante
  2. Le STOPLOSS se situera juste au-dessous du plus bas de cette même bougie
  3. Pour finir le TAKEPROFIT sera placé juste au-dessous de la prochaine résistance

BEOVB

BEOVB

Dans cet nouvel exemple nous nous baserons sur le graphique ci-dessus :

  1. Le prix d’entrée de l’ordre SELL STOP se situera juste au-dessous du plus bas de la bougie enveloppante
  2. Le STOPLOSS se situera juste au-dessus du plus bas de cette même bougie
  3. Pour finir le TAKEPROFIT sera placé juste au-dessus du prochain support

L’algorithme de trading

Si vous avez assidûment lu le début de cet article, vous savez maintenant reconnaître notre pattern « Engulfing »  et entrer correctement sur le marché.

A présent nous allons voir comment créer notre robot de trading.

Pour commencer, ouvrez MetaEditor lié à votre plateforme MetaTrader 4 et créez un nouveau Expert Advisor.

Devant s’ouvre donc une page presque blanche avec les principales fonctions de l’expert advisor.

 

Traduisons la détection de la pattern en algorithme MQL4

Aprs avoir crée un Expert Advisor nous devons détecter si nous sommes en présence de notre pattern à chaque fermeture de bougie.
Pour ce faire nous rajoutons des variables que nous initialiserons.

 

Maintenant détectons nos 2 types de pattern :

 

Puis nous rajoutons :

  • Des paramètres : stop orders, slippage, order expiration time, EA magic number, lot. Le stoploss peut être omis car il est déduit de la stratégie
  • Variables locales : pour convertir les paramètres en variable à exploiter dans l’algorithme
  • Nous avons également besoin d’une variable permettant de quantifier l’écart entre le plus haut ou le plus bas de la bougie enveloppante (pour définir le stoploss et point d’entrée). Ce paramètre se nomme Interval.
  • Une variable permettant de ne pas rentrer plusieurs fois sur le même niveau : timeBUOVB_BEOVB
  • Et une dernière variable pour vérifier la taille de la bougie enveloppante : bar1size

Nous obtenons le code suivant :

Les niveaux d’entrées

Nous sommes capables de trouver nos patterns, nous devons donc définir nos ordres STOP.

Définissons les prix dans la fonction OnTick() :

 

Gérer les erreurs d’exécution

Si vous avez déjà codé un robot de trading, vous savez qu’il y a souvent des erreurs d’exécution renvoyées par le serveur. Nous mettons donc en place une fonction nous permettant de les gérer :

Le code de l’expert advisor dans son ensemble est le suivant :

Conclusion

Dans cet article nous avons :

  1. Abordé un nouveau pattern
  2. Développé l’algorithme de détection
  3. Créé un robot basé sur cet algorithme

Le robot est disponible ici.

 

Traduit de PRICE ACTION. AUTOMATING THE ENGULFING PATTERN TRADING STRATEGY

Read more

Créer ses propres critères d’optimisation sur MT4

Bastien
0 comments
MQL

Introduction

De part et d’autres j’entends souvent parler du manque de choix dans les critères d’optimisation d’un expert advisor dans le testeur de stratégie de MT4. Bien que les développeurs ont certainement essayé de mettre en place tous les critères imaginables, il y aura toujours des situations et des utilisateurs qui en demanderont d’autres.
Pouvons-nous résoudre ou contourner ce problème en langage MQL4 de MetaTrader ? Bien sûr, et cet article vous explique comment le mettre en place sur un example basique du robot de trading Moving Average.

Le critère mis en place sera Profit/Drawdown.

Robot de trading

Commençons par le nouveau critère d’optimisation. Pour le calculer nous allons avoir besoin d’enregistrer la balance maximale ainsi que le drawdown. Dans le but d’éviter toute dépendance avec le robot de trading et son algorithme, nous ajouterons les lignes suivantes tout au début du code :

Dans le but de calculer ce critère jusqu’au dernier tick nous allons devoir répliquer le calcul dans la fonction OnDeinit(). Nous pourrons donc calculer la valeur du critère d’optimisation :

Nous allons à présent nous attaquer au cœur du problème : la gestion de l’optimisation. Malheureusement, MQL4 nous ne permet pas de connaître la fin d’une optimisation, la seule possibilité est d’implémenter un compteur comme seule variable à optimiser. De cette façon à chaque incrémentation du compteur nous saurons que c’est une nouvelle optimisation.

Le principal défaut de cette méthode c’est que l’on perd l’intérêt de pouvoir changer les vrais paramètres du robot de trading. Nous allons devoir les gérer nous même en ajoutant des paramètres. Nous perdrons également en performance car le cache ne sera pas utilisé mais comme on dit « La fin justifie les moyens », continuons avec la liste des variables :

 

Le premier paramètre est notre compteur d’optimisation. La suivante représente le nombre total de passe d’optimisation qui doit coïncider avec le produit des nombres de passe de chaque paramètre de notre robot de trading. Les autres variables représentent les paramètres à optimiser (limite basse, incrément et nombre d’incrémentation).

Après chaque passe, notre robot de trading est appelé à nouveau. Nous avons deux manières de stocker les résultats : des variables globales et un fichier. Nous utiliserons ces deux possibilités.

Nous modifions donc la fonction OnInit() :

 

Le calcul ci-dessus permet d’utiliser le robot de trading comme un algorithme de moyennes mobiles classiques. En effet si TestsNumber=0 alors il n’y aura qu’une seul passage par l’optimisation ce qui revient à un backtest classique. La rapidité de l’optimisation est très importante c’est pour cela que nous mettons en place une variable globale nous permettant de garder en mémoire la position dans le fichier de données.

Le plus gros du travail sera effectué dans le corps de la fonction OnDeinit(). Une fois le test fini nous sauvegardons les données dans un fichier (critères d’optimisation, paramètres et nombre de passage). Une fois l’optimisation terminée, tous les résultats seront classés dans l’ordre du déroulement de l’optimisation.

la spécificité de notre processus c’est que les données sont stockées dans un fichier :

Maintenant, occupons nous du dernier passage :

Nous avions initialisé le notre tableau de données comme double Data[][4]. Un petit nettoyage s’impose :

Let’s Go

Compilez, ouvrez le testeur de stratégie et sélectionnez notre algorithme de trading. Ouvrez les propriétés du robot et vérifier les points suivants :

  • MovingPeriodStepsNumber x MovingShiftStepsNumber  = TestsNumber
  • Dans l’onglet optimisation, seulement le paramètre Counter est sélectionné
  • L’intervalle d’optimisation est compris entre 1 et TestsNumber avec un pas de 1
  • L’algorithme génétique est désactivé

Démarrez l’optimisation.

Une fois terminée rendez vous dans le dossier [Meta Trader]\tester\files et observez les résultats de notre optimisation en ouvrant le fichier test.txt. Vous devriez obtenir un fichier ressemblant à ceci :

log test.txt

Il nous reste une parti important ) traiter car le cache est notre ennemi dans ce nouveau type d’optimisation. En effect, lorsque nous lisons les résultats à partir du cache les fonctions OnInit() et OnDeinit() ne sont pas appelées. Par conséquence, si on redémarre à nouveau notre optimisation une partie (si ce n’est pas tout) de nos paramètres ne sont plus prise en compte. De plus, avec le nombre de passage de l’optimisation sera inférieur à TestsNumbe, notre tableau de données contiendra donc des 0. L’auteur de la solution propose deux solution pour éliminer l’effet du cache :

  • recompilation du robot de trading
  • Fermer/Mettre en pause/Ouvrir la fenêtre du testeur de stratégie

La présence du cache peut être détectée par l’utilisation d’une nouvelle variable globale TestsCnt. Nous allons donc insérer les 3 morceaux de code commentés ci-dessous.

 

Une dernière chose. Une lecteur attentif aura compris que nous pouvons nous débrouiller sans la variable FilePtr (et la variable globale qui l’accompagne) puisque les données sont écrites à la fin du fichier et lues au début.
Mais pourquoi ça ? La réponse est la suivante : ce robot de trading est là pour montrer et démonter la méthode d’optimisation. Ces variables sont là pour gérer  les opérations à la volée. Nous pouvons entre autre définir notre propre algorithme génétique…

Le robot de trading est disponible ici : Archive ZIP.

Si vous avez une question n’hésitez pas à commenter cet article. Et si vous souhaitez que l’équipe de QuantInvest.fr vous ajoute cette fonctionnalité à votre algorithme de trading alors rendez vous sur la page de nos services de développement.

 

Traduit de l’article disponible ici.

Read more

Développer son robot de trading gratuit basé sur un indicateur MT4 (2ième partie)

Bastien
0 comments
MQL

Dans cet article nous allons voir comment un robot de trading peut attraper les signaux d’un indicateur et passer les ordres correspondants sous Metatrader 4 (MT4).
Je vous indique ici comment modifier votre indicateur (à condition d’avoir les sources) et le code de l’algorithme de trading qui se contente de passer les ordres.

La 1ère étape consiste à modifie votre indicateur, pour cela il faut commencer par ajouter les deux fonctions ci-après :

 

Vous l’aurez compris, ces deux fonctions servent respectivement à signaler une ouverture de trade et une fermeture. Le seul et unique paramètre de ces fonctions désigne le type d’action qui doit être passée :
OP_BUY : ouvrir/fermer un ordre à l’achat
OP_SELL : ouvrir/fermer un ordre à la vente

Faites appel à l’une ou l’autre de ces fonctions dans votre indicateur au moment le plus approprié, par exemple, si votre indicateur vous alerte visuellement, repérez l’appel à la fonction Alert et ajoutez à la suite la fonction de signal adéquate.

La deuxième étape consiste à créer/modifier un expert advisor qui récupérera les signaux soumis par le ou les indicateurs et qui passera les ordres en conséquence.
L’exemple ci-après est simpliste et peut (doit) être amélioré pour gérer à minima un money management
On peut également imaginer un indicateur qui signale le stoploss le plus judicieux et qui sera pris en compte par le robot de trading sur le même modèle pour calculer au mieux la taille de la position.

 

Le fonctionnement du robot de trading est donc le suivant :

  • Vous ouvrez un graphique et sélectionnez le TF
  • Vous placez l’EA sur le graphique, il commencera à inspecter les signaux
  • Vous placez un indicateur qui vous signalera les points de sortie
  • Vous placez enfin un indicateur qui vous signalera les points d’entrée

Vous avez la possibilité de dupliquer ce schéma autant de fois que nécessaire en pensant à différencier à chaque fois le paramètre commentaire associé à chaque graphique.

Read more

Développer son robot de trading basé sur un indicateur MT4 (1ère partie)

Bastien
0 comments
MQL

Lorsque je gérais un autre site sur le forex j’ai écrit un article permettant d’être autonome sur la création d’algorithme de trading à partir d’un indicateur.
Je vous propose de le partager à nouveau avec vous sur QuantInvest.fr
Des outils automatisés existent en ligne mais rien ne vaut la maîtrise de son développement et donc de son robot de trading.

Tout d’abord il vous faut lancer le logiciel « MetaEditor » fournit avec la plateforme MT4 (vous le trouverez dans le menu de vos programmes sous Metatrader)

Ensuite il faut faire :

  1. Fichier -> Nouveau
  2. Dans la fenêtre qui suit sélectionner Expert Consultant (modèle) -> Suivant
  3. Remplir le champ Nom (Vous pouvez ajouter des paramètres externes en cliquant sur Ajouter) -> Suivant.
  4. Cliquer sur Suivant (les options de cet onglet ne sont pas nécessaire pour notre article).
  5. Cliquer sur Terminer (idem options non nécessaires).

Un fichier s’ouvre il comporte 3 fonctions : OnInit()OnDeinit() et OnTick()
Comme vous pouvez le constater le corps d’une fonction est encadrée par deux accolades { }.

  • OnInit() : C’est la fonction qui est appelée lorsque le robot de trading est attaché à un graphique ou si vous changez les paramètre du robot.
  • OnDeinit() : Cette fonction est appelé lorsque vous désactivez l’expert advisor. C’est à dire lorsque vous le supprimez du graphe en cours ou si vous cliquez sur le bouton « Expert Advisors »
  • OnTick() : Cette fonction est appelée à chaque tick, elle contiendra la logique de votre robot de trading.

*Paramètres d’entrées : les paramètres d’entrées permettent de modifier des variables à l’extérieur du code, plus précisément dans la boite de dialogue qui s’ouvre lorsque vous attachez le robot au graphe. Ils sont de la forme « extern nomDuParamètre; »
Les différents types sont les suivants:

  • int : un nombre entier
  • double : un chiffre décimale
  • bool : un booléen, ça valeur sera FALSE ou TRUE
  • string : Une chaîne de caractère (une phrase dans le cas général)
  • datetime : Une date comportant le jour, mois, année et l’heure.

En principe pour faire un robot de trading les paramètres de base utilisés sont les suivants :

  • MagicNumber : Le numéro d’identification du robot de trading permettant de retrouver ses ordres
  • lot : La taille des lots des trades (pour un lot fixe)
  • stoploss : Valeur en pips du SL des trades effectués par l’expert advisor
  • takeprofit : Valeur en pips du TP des trades effectués par l’expert advisor

Pour notre exemple je pense que ceux-ci suffiront.

Pour plus de renseignement vous pouvez aller voir la documentation MQL4 (le langage de MT4) sur : http://docs.mql4.com/index

Passons aux choses sérieuses…

Quels indicateurs allons nous utiliser pour cet exemple ? La réponse est Moving Average plus communément appelé MA.
Bon ok vous vous en doutiez….

Mais comment appelez cette indicateur ?
Une chose importante : Tout indicateur appelé par un EA doit être placé dans le dossier Indicators !

Il existe deux types d’appels :

— Appeler les indicateurs natifs de MT4—

Metatrader a été sympa ils ont crée des fonctions permettant facilement d’appelé leurs indicateurs, vous les trouverez à cette adresse : http://docs.mql4.com/indicators

Exemple

Prenons l’indicateur MA : le prototype de sa fonction est le suivant
double iMA( string symbol, int timeframe, int period, int ma_shift, int ma_method, int applied_price, int shift)
>> Symbol : Mettre NULL pour utiliser la paire courante
>> timeframe : Mettre 0 pour utiliser le TF courant (Certain vont se dire : MMMmmmmhh je peux faire du multiframe alors… Et bien OUI)
>> period : La période de votre MA, ici nous utiliserons 5 et 13 pour la deuxième.
>> ma_shift : Offset de l’indicateur
>> ma_method : A choisir parmi les suivantes (MODE_SMA, MODE_EMA, MODE_SMMA, MODE_LWMA)
>> applied_price : A choisir parmi les suivants (PRICE_OPEN , PRICE_CLOSE , PRICE_HIGH , PRICE_LOW , PRICE_MEDIAN , PRICE_TYPICAL , PRICE_WEIGHTED)
>> shift : Offset horizontal (utile pour détecter les croisements)

Donc au final nous obtenons ceci : iMA(NULL,0,5,0,MODE_SMMA,PRICE_CLOSE,0)

— Appeler mes indicateurs personnels —

Rien de plus facile encore un grand merci a Metatrader pour la fonction iCustom : Vous trouverez des explications à cette adresse : http://docs.mql4.com/indicators/iCustom

Exemple

double iCustom( string symbol, int timeframe, string name, …, int mode, int shift)
>> Symbol , timeframe et shift sont identiques aux paragraphes au-dessus
>> name : Vous devez mettre le nom exact de votre indicateurs situé dans le dossier Indicators.
>> : Correspond aux paramètres externes de l’indicateur, vous devez les mettre dans l’ordre exact dans lequel ils sont disposés dans la boite de dialogue.
>> mode : C’est option est plus technique, il faut savoir qu’un indicateur se compose de plusieurs buffers (par exemple si vous prenez un indicateur qui vous signale un achat ou une vente par deux flèches celui-ci « en général » comportera deux buffers). Cette option permet de choisir le buffer à lire.

Passons à un exemple concret : Nous allons appeler l’indicateur « Moving Averages » placé dans indicateurs personnalisés.
Donc si je veux l’appeler je fais comme ceci :
iCustom(NULL,0, »Moving Averages »,5,0,MODE_SMMA,0,0);

C’est fini ! Voici le code:

Read more

Calculer la taille de lots en fonction du risque

Bastien
0 comments
MQL

On se demande souvent comment intégrer précisément la taille de lots en fonction d’un risque choisi à l’avance (souvent exprimé en pourcentage) dans son robot de trading.
Le but de cet article est d’y répondre une bonne fois pour toute ;)

Il faut savoir que ce calcul va dépendre de la monnaie de votre compte.
Mais pas seulement, le risque va s’exprimer en fonction de la paire qu’on trade. La taille de lots va donc changer en fonction de cette dernière.

Passons aux choses sérieuses, voici la fonction tant attendue :

Les paramètres sont les suivants :

  • percent : Le risque exprimé en pourcentage (2.2 = 2.2%)
  • stoploss : Le prix où sera placé le stoploss (par exemple 1.20365)

Cette fiche était déjà présente sur mon précédent site donc n’hésitez pas si vous souhaitez plus de détails.

J’espère que cette fonction vous sera utile autant pour les débutants que les plus confirmés.

Si vous souhaitez faire développer ou améliorer vos robots de trading, nous proposons une gamme de service ici.

Articles conseillés :

Trader plus facilement avec VOTRE robot de trading !

Profitez des meilleures conditions de trading avec le sérieux du broker XTB : ouvrir un compte en moins de 5 minutes.

 

Read more

Disclaimer

Les informations de marchés et les analyses fournies restent à titre indicatif et ne doivent pas être interprétées comme un conseil, une recommandation ou une sollicitation d’investissement. QuantInvest ne peut être tenu responsable de l’utilisation qui en est faite et des conséquences qui en résultent, l’investisseur final restant le seul décisionnaire quant à la prise de position sur son compte de trading.