Apprenez à concevoir un système de trading à l'aide du Gator Oscillator
146
0
Introduction
Nous couvrirons cet indicateur autant que possible à travers les thèmes suivants :
- Définition du Gator Oscillator
- Stratégie du Gator Oscillator
- Schéma du Gator Oscillator
- Système de trading Gator Oscillator
- Conclusion
Nous utiliserons le terminal de trading MetaTrader 5 pour tester la stratégie mentionnée et construire notre système de trading à l'aide du langage de programmation MetaQuotes (MQL5) qui est intégré à MetaTrader 5. Si vous ne savez pas comment télécharger et utiliser MetaTrader 5 et l'IDE de MQL5, vous pouvez lire la rubrique « Écrire du code MQL5 dans MetaEditor » de mon article précédent pour en savoir plus sur ce sujet.
Je dois mentionner ici que vous devez tester toute stratégie mentionnée avant de l'utiliser pour vous assurer qu'elle sera utile et rentable pour vous car il n'existe rien qui convienne à tout le monde. L’objectif principal ici est éducatif seulement pour apprendre le concept principal et la racine derrière l'indicateur. Il y a également un conseil que je dois mentionner ici : vous devez essayer d'écrire les codes de cet article et d'autres par vous-même si vous voulez améliorer vos compétences en programmation.
Avertissement : Toutes les informations données dans cet article sont fournies "en l'état", uniquement à des fins d'information et ne sont aucunement données à des fins de trading ou de conseil. Ces informations ne garantissent aucun type de résultat. Si vous utilisez le contenu de cet article sur l'un de vos comptes de trading, vous le faites à vos propres risques et vous en serez le seul responsable.
Définition du Gator Oscillator
Dans cette partie, nous allons identifier l'indicateur Gator Oscillator de manière plus détaillée afin de comprendre et de reconnaître le concept principal qui le sous-tend et de l'utiliser de manière appropriée et efficace. L'indicateur Gator Oscillator a été créé par Bill Williams pour nous aider à déterminer si le marché est en train de suivre une tendance ou pas. S'il y a une tendance, comment cette tendance peut continuer en termes d'élan, en plus de donner le moment d'entrer ou de sortir d'une transaction. Comme nous le savons tous, ces deux éléments sont très importants dans le trading. Le Gator Oscillator est basé sur l'indicateur Alligator. Vous pouvez lire mon précédent article Apprendre à concevoir un système de trading basé sur l’Alligator pour plus de détails sur l’indicateur Alligator.
Le calcul de l'indicateur Gator est le même que celui que nous allons voir en montrant la convergence et la divergence des lignes d'équilibre de l'indicateur Alligator. Ce qui suit concerne le calcul de l'indicateur Gator :
- Première étape : nous devons calculer le prix médian :
Prix médian = (haut + bas) /2
- Deuxième étape : nous devons calculer les Mâchoires (Jaws), les Dents (Teeth) et les Lèvres (Lips) de l'Alligator :
Alligator Jaws = SMMA (Prix médian, 13, 8)
Alligator Teeth = SMMA (Prix médian, 8, 5)
Alligator Lips = SMMA (Prix médian, 5, 3)
- Avec :
Prix médian : le type de prix.
Haut : la valeur de prix la plus élevée.
Bas : la valeur du prix la plus basse.
SMMA : la moyenne mobile lissée est un type de moyenne mobile, qui permet de lisser les données, la période et le décalage s'il existe. SMMA (Prix médian, 13, 5) signifie que la SMMA, qui est la moyenne mobile lissée dérivée du prix médian comme type de données, la période de lissage est de 13, et le décalage vers la droite (le futur) sera de 5.
Alligator Jaws (Mâchoires de l'Alligator) : la ligne bleue de l'indicateur Alligator.
Alligator Teeth (Dents de l'Alligator) : la ligne rouge de l'indicateur Alligator.
Alligator Lips (Lèvres de l'Alligator) : la ligne verte de l'indicateur d'Alligator.
Le calcul précédent produit l'indicateur Gator Oscillator. Mais nous n'avons pas besoin de le calculer manuellement car il est intégré dans MetaTrader 5. Nous n’avons qu’à le choisir parmi les autres indicateurs techniques disponibles et l'insérer dans le graphique comme suit.
En ouvrant MetaTrader 5, choisissez l'onglet Insertion --> Indicateurs --> Bill Williams --> Gator Oscillator
Après avoir sélectionné Gator Oscillator, la fenêtre des paramètres de Gator est affichée :
Dans la figure précédente, les paramètres de l'indicateur Gator Oscillator permettent de déterminer les réglages de l'indicateur :
- La période des Mâchoires (Jaws)
- Le décalage horizontal des Mâchoires (Jaws)
- La période des Dents (Teeth)
- Le décalage horizontal des Dents (Teeth)
- La période des Lèvres (Lips)
- Le décalage horizontal des Lèvres (Lips)
- La méthode de calcul de la moyenne
- Le type de prix qui sera utilisé dans le calcul du Gator
- La couleur des valeurs haussières de Gator
- La couleur des valeurs baissières de Gator
- L'épaisseur des barres du Gator
Après avoir déterminé tous les paramètres préférés de l'indicateur Gator Oscillator, l'indicateur sera attaché au graphique dans la partie inférieure du graphique comme suit :
Comme nous pouvons le voir dans le graphique précédent, nous avons l'indicateur avec les valeurs à la hausse et à la baisse de l'Oscillateur Gator. Les valeurs à la hausse sont visibles au-dessus de zéro et les valeurs à la baisse en dessous de zéro. Nous avons également des barres vertes et rouges basées sur la relation entre chaque barre et la précédente. Si la barre actuelle est supérieure à la précédente, la barre actuelle est verte. Et vice versa, si la barre actuelle est inférieure à la précédente, la barre actuelle est rouge.
Stratégie du Gator Oscillator
Dans cette rubrique, je vais partager avec vous quelques stratégies simples qui peuvent être utilisées par l'indicateur Gator Oscillator à des fins d'apprentissage uniquement. Vous devez tester toute stratégie mentionnée avant de l'utiliser sur un compte réel afin de vous assurer qu'elle vous sera utile.
Sur la base de cette stratégie, nous devons identifier le statut de l’Alligator (Gator) en fonction des barres de l'indicateur. En conséquence, nous aurons 4 statuts. Si les deux barres sont rouges, le statut du Gator sera une phase de sommeil. Si les deux barres sont vertes, il s'agit d'une phase d'alimentation. Si la barre est verte après une barre rouge, il s'agit de la phase d'éveil. Si la barre est rouge après une barre verte, il s'agit d'une phase de satiété.
Plus simplement :
Les 2 barres sont rouges ==> Phase de sommeil
Les 2 barres sont vertes ==> Phase d'alimentation
Barre rouge suivie d’une barre verte ==> Phase d'éveil
Barre verte suivie d’une barre rouge ==> Phase de satiété
Selon cette stratégie, nous devons obtenir des signaux basés sur l'indicateur Gator. Si l'alligator est en phase de réveil, nous avons besoin d'un signal pour trouver une bonne entrée. Si l'indicateur Gator est en phase de consommation, nous devons obtenir un signal de maintien de la position actuelle. Si l'indicateur Gator est en phase de satiété, il faut trouver une bonne sortie. Si le statut de Gator est autre chose, nous ne devons rien obtenir.
Plus simplement :
Gator = Phase d'éveil ==> Trouver une bonne entrée.
Gator = Phase d'alimentation ==> Maintien de la position actuelle.
Gator = Phase de satiété ==> Trouver une bonne sortie.
Gator = autre chose ==> Ne rien faire.
Dans cette stratégie, nous combinerons le signal Gator avec le signal de la moyenne mobile. Si nous avons deux barres vertes et que le prix de clôture est supérieur à la valeur de la moyenne mobile, il s'agira d'un signal de recherche de bonne position d'achat. Dans l'autre scénario, si l'indicateur Gator a deux barres rouges et que le prix de clôture est inférieur à la valeur de la moyenne mobile, il s'agira d'un signal de recherche de bonne position de vente. Ou, si nous avons autre chose, nous ne devons rien faire.
Plus simplement :
Double barre verte et le prix de clôture > la moyenne mobile ==> Trouver une bonne position d'achat.
Double barre rouge et cours de clôture < la valeur de la moyenne mobile ==> Trouver une bonne position de vente.
Autre chose ==> Ne rien faire
Schéma du Gator Oscillator
Dans cette partie, nous créerons des plans étape par étape pour chaque stratégie afin de nous aider à créer notre système de trading efficacement et facilement. Je pense que cette étape est très importante et essentielle pour le développement d'un système de trading. Elle permet de gagner beaucoup de temps, même si la création prend du temps, car elle permet d'éviter d'oublier une étape importante et de répéter des tâches. Nous nous efforcerons de comprendre ce que nous devons laisser l'ordinateur faire pour nous en organisant nos idées en étapes claires.
En se basant sur le concept de cette stratégie, nous devons créer un Expert Advisor qui vérifiera automatiquement certaines valeurs de l'indicateur Gator à chaque tick : la hausse actuelle, les 2 hausses précédentes de la hausse actuelle, et la baisse actuelle, et les 2 baisses précédentes de la baisse actuelle. Après cette vérification, l'EA doit déterminer la position de chaque valeur et effectuer les comparaisons suivantes : la première consiste à comparer les valeurs du Gator up actuel et précédent et à déterminer laquelle est supérieure à l'autre ; la seconde consiste à comparer les valeurs du Gator down actuel et précédent et à déterminer laquelle est supérieure à l'autre. Le résultat de cette comparaison constituera les signaux souhaités pour identifier le statut de l’Alligator.
Si la valeur actuelle à la hausse est inférieure à la précédente, et que la valeur actuelle à la baisse est supérieure à la précédente, l'EA ou le système de trading doit renvoyer un signal de la phase de sommeil sous la forme d'un commentaire sur le graphique. Dans un autre cas, si la valeur actuelle à la hausse est supérieure à la précédente et que, dans le même temps, la valeur actuelle à la baisse est inférieure à la précédente, le système de trading doit renvoyer un signal de la phase de consommation sous forme de commentaire sur la phase actuelle. Dans le troisième cas, si la première valeur à la hausse précédente est inférieure à la deuxième valeur précédente, et que la première valeur à la baisse précédente est supérieure à la deuxième valeur à la baisse précédente, et qu'en même temps, la valeur à la hausse actuelle est supérieure à la première valeur précédente et que la valeur à la baisse actuelle est inférieure à la première valeur précédente, le système de trading doit renvoyer un commentaire sur le graphique avec le signal de la phase d'éveil. Dans le quatrième et dernier état, si la première valeur précédente à la hausse est supérieure à la deuxième et que la première valeur précédente à la baisse est inférieure à la deuxième, et que, dans le même temps, la valeur actuelle à la hausse est inférieure à la première précédente et que la valeur actuelle à la baisse est supérieure à la première précédente, le système de trading doit renvoyer un commentaire sur le graphique avec un signal de phase de satiété.
Le graphique suivant est un simple schéma de ce système de trading :
Deuxième stratégie : Les Signaux de l’Alligator (Gator Signals)
Selon l'idée principale de cette stratégie de trading, nous devons créer un système de trading qui peut être utilisé pour renvoyer un signal de bon timing d'entrée, de sortie ou de maintien de la position actuelle. Pour ce faire, nous avons besoin que le système de trading vérifie continuellement les valeurs de la hausse actuelle et des 2 hausses précédentes en plus de la baisse actuelle et des 2 baisses précédentes afin d'obtenir un signal basé sur le statut de l’Alligator.
Le premier signal que le système de trading doit renvoyer est « Trouver une bonne entrée » (« Find a good entry ») sous la forme d’un commentaire sur le graphique après avoir vérifié les valeurs de l’Alligator et constaté qu'il y a eu une phase de réveil (la première valeur précédente à la hausse est plus petite que la deuxième valeur précédente et la première valeur précédente à la baisse est plus grande que la deuxième et en même temps, la valeur actuelle à la hausse est plus grande que la première valeur précédente et la valeur actuelle à la baisse est plus petite que la première valeur précédente).
Le deuxième signal que nous devons obtenir par le système de trading est « Tenir la position actuelle » (« Hold current position ») sous la forme d’un commentaire sur le graphique après avoir vérifié les valeurs de l’Alligator et constaté qu'il y a eu une phase de consommation (la valeur actuelle à la hausse est supérieure à la première valeur précédente et que la valeur actuelle à la baisse est inférieure à la première valeur précédente).
Le troisième signal que nous devons obtenir avec ce système de trading est « Trouver une bonne sortie » (« Find a good exit ») sous la forme d’un commentaire sur le graphique après avoir vérifié les valeurs de l’Alligator et constaté qu'il y a eu une phase de saturation (la première valeur précédente à la hausse est supérieure à la deuxième valeur précédente et la première valeur précédente à la baisse est supérieure à la deuxième valeur précédente).
La dernière chose dont nous avons besoin dans le système de trading est de ne rien faire dans toutes les autres situations. Voici le modèle de ce système de trading :
3ème stratégie : Alligator avec MA
Selon la stratégie de trading, nous devons trouver le bon moment pour acheter ou vendre des positions sur la base de l'indicateur Gator, du prix de clôture et de la moyenne mobile. Comme nous l'avons appris dans la section sur la stratégie, voici comment laisser l'ordinateur s'en charger.
Le premier signal que le système de trading doit renvoyer est « Trouver une bonne position d'achat » (« Find a good buy position ») lorsque l'on vérifie les valeurs de l’Alligator et que l'on constate que la hausse actuelle est supérieure à la première hausse précédente et que la première hausse précédente est supérieure à la deuxième hausse précédente et que, dans le même temps, la baisse actuelle est inférieure à la première baisse précédente et que la première baisse précédente est inférieure à la deuxième baisse précédente. Cela signifie que nous avons maintenant 2 barres vertes. Le prix de clôture est alors supérieur à la valeur de la moyenne mobile.
Le deuxième signal consiste à obtenir « Trouver une bonne position de vente » (« Find a good sell position ») en vérifiant l’Alligator et en constatant que la hausse actuelle est plus petite que la première précédente et que la première hausse précédente est plus petite que la deuxième précédente et que, dans le même temps, la valeur de la baisse actuelle est plus grande que la première précédente et que la première baisse précédente est plus grande que la deuxième précédente. Ceci signifie que nous avons 2 barres rouges. Dans ce cas, le prix de clôture est inférieur à la moyenne mobile.
La troisième chose dont nous avons besoin est que le système de trading ne doit rien renvoyer dans les autres cas. Voici le modèle de ce système de trading :
Système de trading Gator Oscillator
Nous en arrivons maintenant au sujet le plus intéressant de cet article, à savoir la création de notre système de trading pour chaque stratégie. Ce système de trading peut nous aider à négocier efficacement. Nous allons commencer à créer un système de trading simple qui servira de base à nos stratégies.
Le "Simple Gator Oscillator System" est créé pour renvoyer un commentaire sur le graphique avec la valeur actuelle à la hausse et à la baisse de l'indicateur Gator. Les étapes suivantes permettent de créer ce système de trading :
Création des tableaux de upGator et de downGator de type double, l'un des types réels permettant de renvoyer des valeurs avec des fractions.
double upGatorArray[]; double downGatorArray[];
Tri des données dans ces tableaux à l'aide de la fonction "ArraySetAsSeries". Ses paramètres sont :
ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true);
Création d'une variable entière pour gatorDef et définition du Gator Oscillator à l'aide de la fonction "iGator" qui retourne un handle sur l'indicateur. Ses paramètres sont :
- symbole : pour déterminer le nom du symbole, nous utiliserons _SYMBOL pour le symbole actuel.
- period : pour déterminer la période, nous utiliserons _PERIOD qui s'appliquera à la période actuelle.
- jaw_period : pour déterminer la période souhaitée pour le calcul des Mâchoires, nous utiliserons 13.
- jaw_shift : pour déterminer le décalage horizontal des Mâchoires si nécessaire. Nous utiliserons 8.
- teeth_period : pour déterminer la période de calcul des Dents. Nous utiliserons 8.
- teeth_shift : pour déterminer le décalage horizontal des Dents si nécessaire. Nous utiliserons 5.
- lips_period : pour déterminer la période de calcul des Lèvres. Nous utiliserons 5.
- lips_shift : pour déterminer le décalage horizontal des Lèvres si nécessaire. Nous utiliserons 3.
- ma_method : pour déterminer le type de moyenne mobile. Nous utiliserons MODE_SMMA.
- applied_price : pour déterminer le type de prix appliqué dans le calcul. Nous utiliserons PRICE_MEDIAN.
int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
Définition des données et stockage des résultats à l'aide de la fonction "CopyBuffer" pour upGatorArray et downGatorArray. Ses paramètres sont :
- indicator_handle : pour déterminer le handle de l'indicateur, nous utiliserons gatorDef.
- buffer_num : pour déterminer le numéro de buffer de l'indicateur, nous utiliserons 0 pour upGator, 2 pour downGator.
- start_pos : pour déterminer la position de départ, nous utiliserons 0.
- count : pour déterminer le nombre d’éléments à copier, nous utiliserons 3.
- buffer[] : pour déterminer le tableau cible à copier, nous utiliserons upGatorArray et downGatorArray.
CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray);
Obtention des valeurs de upGator et downGator après avoir créé des variables de type double. Nous utiliserons ensuite la fonction NormalizeDouble pour arrondir les chiffres.
- value : Nous utiliserons upGatorArray[0] pour la valeur actuelle.
- digits : Nous utiliserons 6 pour le nombre de chiffres après la virgule.
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6);
Utilisation de la fonction Comment pour faire apparaître les valeurs de l'upGator et du downGator en cours.
Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue);
Voici le code complet de ce système de trading :
//+------------------------------------------------------------------+ //| Simple Gator Oscillator System.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue); } //+------------------------------------------------------------------+
Après avoir écrit les lignes de code précédentes, nous les compilerons, en nous assurant qu'il n'y a pas d'erreurs. Puis nous trouverons cet expert dans la fenêtre du Navigateur sous le dossier Expert Advisors dans le terminal de trading MetaTrader 5 :
En glissant et déposant l'expert sur le graphique désiré, la fenêtre de l’EA est affichée comme suit :
Après avoir coché la case « Autoriser le Trading Algo » et appuyé sur le bouton OK, l'EA est attaché au graphique :
Le système de trading est maintenant prêt à générer des signaux comme dans ce test :
Première stratégie : Identification du Statut de l’Alligator
Sur la base de cette stratégie, voici le bloc de code complet qui permet de la créer :
//+------------------------------------------------------------------+ //| Gator Status Identifier.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,5,upGatorArray); CopyBuffer(gatorDef,2,0,5,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); } else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); } if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); } else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); } } //+------------------------------------------------------------------+
Voici les différences dans ce code :
Définition et obtention des 3 dernières valeurs de upGator :
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6);
Définition et obtention des 3 dernières valeurs de downGator :
double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6);
Conditions de la stratégie :
Dans le cas de la phase de sommeil,
if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); }
Dans le cas de la phase d'alimentation,
else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); }
Dans le cas de la phase d'éveil,
if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); }
Dans le cas de la phase de saturation,
else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); }
Après avoir compilé ce code sans erreur et exécuté l'EA, nous constaterons qu'il est attaché au graphique comme suit :
Comme nous pouvons le voir dans le coin supérieur droit du graphique précédent, l'EA Identification du Statut de l’Alligator est attaché au graphique.
Les signaux basés sur cette stratégie sont générés à partir de tests :
Dans le cas d'un signal dormant :
Comme nous pouvons le voir sur le graphique précédent, dans le coin supérieur gauche, nous avons un signal de la phase de sommeil basé sur cette stratégie.
Dans le cas de la phase d'alimentation :
Sur la base du graphique précédent, nous pouvons constater dans le coin supérieur gauche que nous avons un signal de phase d’alimentation dépendant de cette stratégie.
Dans le cas de la phase d'éveil :
Comme nous pouvons le voir dans le graphique précédent, nous avons un signal de phase d'éveil basé sur la stratégie Gator Status Identifier.
Dans le cas de la phase de saturation :
Comme nous pouvons le voir dans la figure précédente, nous avons une phase de satiété dans le coin supérieur gauche.
Le code complet permettant de créer un système de trading basé sur cette stratégie est présenté ci-dessous :
//+------------------------------------------------------------------+ //| Gator signals.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1; if(awakeningPhase) { Comment("Find a good entry"); } else if(eatingPhase) { Comment("Hold current position"); } else if(satedPhase) { Comment("Find a good exit"); } else Comment(""); } //+------------------------------------------------------------------+
Différences dans cette stratégie :
Création d'une variable bool pour les 3 phases suivantes : awakeningPhase, eatingPhase et satedPhase
bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1;
Conditions de la stratégie :
Dans le cas de la phase d'éveil
if(awakeningPhase) { Comment("Find a good entry"); }
Dans le cas de la phase d'alimentation
else if(eatingPhase) { Comment("Hold current position"); }
Dans le cas de la phase de saturation
else if(satedPhase) { Comment("Find a good exit"); }
Autres
else Comment("");
Après avoir compilé ce code et l'avoir exécuté, nous constaterons que l'EA est attaché au graphique comme suit :
Comme nous pouvons le voir dans le coin supérieur droit, l'EA des Signaux de l’Alligator est attaché au graphique.
Nous sommes maintenant prêts à recevoir les signaux de cette stratégie. Les exemples suivants sont tirés de nos tests :
Dans le cas de la phase d'éveil :
Comme nous pouvons le voir dans le graphique précédent, nous avons un signal "Trouver une bonne entrée" dans le coin supérieur gauche.
Dans le cas de la phase d'alimentation :
Comme nous pouvons le voir dans la figure précédente, nous avons un signal "Maintenir la position actuelle" dans le coin supérieur gauche.
Dans le cas de la phase de saturation
Comme nous pouvons le voir dans le graphique précédent, nous avons un signal "Trouver une bonne sortie" dans le coin supérieur gauche.
3ème stratégie : Alligator avec la stratégie de la MA
Voici le code complet permettant de créer un système de trading basé sur cette stratégie.
//+------------------------------------------------------------------+ //| Gator with MA strategy.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; MqlRates pArray[]; double maArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); ArraySetAsSeries(maArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE); int data=CopyRates(_Symbol,_Period,0,13,pArray); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); CopyBuffer(maDef,0,0,3,maArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); double maValue=NormalizeDouble(maArray[0],5); double closingPrice=pArray[0].close; bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&& gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2; bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&& gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2; if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); } else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); } else Comment(""); } //+------------------------------------------------------------------+
Différences dans cette stratégie :
Création de 2 autres tableaux pour pArray et maArray. Nous utiliserons le type "MqlRates" pour pArray afin de stocker des informations sur les prix, et le type "double" pour maArray
MqlRates pArray[]; double maArray[];
Tri des données dans maArray en utilisant la fonction "ArraySetAsSeries"
ArraySetAsSeries(maArray,true);
Création d'une variable de type integer pour maDef et définition de la moyenne mobile en utilisant la fonction "iMA" pour renvoyer le handle de l'indicateur. Ses paramètres sont :
- symbole : pour déterminer le nom du symbole. Nous utiliserons _SYMBOL à appliquer pour le graphique actuel.
- period : pour déterminer la période, nous utiliserons _PERIOD qui s'applique à la période actuelle. Vous pouvez également définir PERIOD_CURRENT pour la même chose.
- ma_period : pour déterminer la période de la moyenne, nous utiliserons 13.
- ma_shift : pour déterminer le décalage horizontal si nécessaire. Nous mettrons 0 car nous n'avons pas besoin de décaler la MA.
- ma_method : pour déterminer le type de moyenne mobile, nous choisirons EMA (Exponential Moving Average).
- applied_price : pour déterminer le type de prix utilisé dans le calcul, nous utiliserons le prix de clôture.
int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE);
Obtention des données historiques de MqlRates en utilisant la fonction "CopyRates" :
- symbol_name : pour déterminer le nom du symbole, nous utiliserons _Symbol pour le symbole actuel.
- timeframe : pour déterminer la période. Nous utiliserons _Period à appliquer pour la période actuelle.
- start_pos : pour déterminer la position ou le point de départ, nous utiliserons 0 pour partir de la position actuelle.
- count : pour déterminer le nombre de copies à effectuer, nous utiliserons 13.
- rates_array[] : pour déterminer la cible du tableau à copier, nous utiliserons pArray.
int data=CopyRates(_Symbol,_Period,0,13,pArray);
Définition des données et stockage des résultats à l'aide de la fonction "CopyBuffer" pour maArray.
CopyBuffer(maDef,0,0,3,maArray);
Obtention et normalisation de la valeur de la moyenne mobile exponentielle actuelle.
double maValue=NormalizeDouble(maArray[0],5);
Obtention de la valeur actuelle du prix de clôture.
double closingPrice=pArray[0].close;
Création des variables bool des double barres vertes et des doubles barres rouges de l'indicateur Gator Oscillator.
bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&&
gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2;
bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&&
gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2; Conditions de la stratégie :
En cas d'achat :
if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); }
En cas de vente :
else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); }
Autres :
else Comment("");
Après avoir compilé et exécuté ce code pour l'attacher au graphique souhaité, l'EA est attaché au graphique de la manière suivante :
Comme nous pouvons le voir dans le coin supérieur droit du graphique, l'EA de l’Alligator avec MA est attaché au graphique.
Nous sommes maintenant prêts à recevoir les signaux de cette stratégie. Les exemples suivants sont tirés de nos tests :
En cas d'achat :
Comme nous pouvons le voir dans la figure précédente, dans le coin supérieur gauche, nous avons un signal « Trouver une bonne position d'achat ».
En cas de vente :
Comme nous pouvons le voir, nous avons un signal « Trouver une bonne position de vente ».
Nous avons maintenant appris comment créer des systèmes de trading basés sur différentes stratégies. Cette approche doit vous ouvrir les yeux sur les différentes idées que vous pouvez appliquer - c'est l'objectif principal de cet article et de cette série.
Conclusion
Nous avons maintenant couvert tous les sujets de cet article pour apprendre à concevoir un système de trading avec le Gator Oscillator. Nous avons appris ce qu'est l'indicateur Oscillateur Gator, comment le calculer, comment l'utiliser à travers 3 stratégies de trading simples qui sont :
- Identification du Statut de l’Alligator : cette stratégie détermine l'état du Gator Oscillator (éveil, sommeil, alimentation, satiété) en fonction de différentes conditions.
- Signaux de l’Alligator : pour obtenir des signaux sur la décision appropriée (trouver une bonne entrée, maintenir la position actuelle, ou trouver une bonne sortie) sur la base de différentes conditions du Gator Oscillator.
- Stratégie Gator avec MA : pour obtenir des signaux sur le timing des positions d'achat ou de vente en se basant sur le Gator Oscillator avec une moyenne mobile.
Nous avons ensuite appris à créer un schéma directeur étape par étape pour nous aider à créer un système de trading pour chaque stratégie, de manière efficace et facile. Nous avons ensuite créé un système de trading pour ces stratégies à exécuter sur la plateforme de trading MetaTrader 5 en créant le code source dans l'IDE MQL5.
J'espère que vous avez trouvé cet article utile pour vous aider à obtenir de meilleurs résultats dans votre trading. J'espère aussi que ce compte vous a aidé à trouver une nouvelle approche qui peut être utilisée dans votre activité de trading ou à obtenir plus d'informations sur le sujet de cet article ou tout autre sujet connexe. Si cela se produit et que vous voulez lire d'autres articles similaires, vous pouvez lire mes autres articles dans cette série sur l'apprentissage de la conception d'un système de trading basé sur les indicateurs techniques les plus populaires.
Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/11928
Comment Échanger des Données : Une DLL pour MQL5 en 10 minutes
Comment traiter les niveaux avec MQL5
L'Histogramme des prix (Profile du Marché) et son implémentation en MQL5
Modèles de classification dans la bibliothèque Scikit-Learn et leur export vers ONNX
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation