Comment utiliser MQL5 pour détecter des figures de chandeliers ?

MetaTrader 5 — Trading | 27 novembre 2024, 09:39

1 007

Mohamed Abdelmaaboud

Introduction

Les chandeliers sont un outil technique très utile si nous les utilisons correctement, car nous pouvons trouver un mouvement potentiel grâce à leurs motifs. Les chandeliers peuvent former des configurations spécifiques sur le graphique. Ces configurations peuvent être divisées en 2 types : les configurations à bougie unique et les configurations à bougies multiples (deux bougies ou plus). Dans cet article, nous allons apprendre comment utiliser MQL5 pour détecter automatiquement certains de ces modèles dans le terminal de trading MetaTrader 5 :

Je dois mentionner qu'il est très important d'utiliser ces modèles accompagnés d'autres outils techniques pour obtenir des signaux significatifs. Vous devez donc comprendre l'idée principale de la détection des modèles mentionnés par MQL5 pour qu'ils fassent partie de votre système de trading afin de faciliter vos transactions et d'obtenir de bons résultats.

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.

Modèle à 1 bougie

Dans cette partie, nous verrons 2 exemples de figures populaires à un seul chandelier qui apparaissent sur le graphique. Vous pouvez les voir sur n'importe quelle période. Ils seront plus significatifs lorsqu'ils se produisent relativement à l'action du prix. Nous verrons les motifs Doji et Hammer.

Modèle de Doji

Il s'agit d'une bougie qui a presque le même prix d'ouverture et de fermeture, on peut voir un très petit corps de bougie ou une ligne sur le graphique pour le même prix avec un corps supérieur et un corps inférieur, voire aucune ombre. La figure suivante correspond à cette bougie :

Doji

Cette bougie Doji indique qu'il y a un équilibre entre les acheteurs et les vendeurs et que personne ne contrôle le marché pour faire monter ou descendre le prix pendant la période où elle apparaît. Elle peut signaler un renversement ou une correction du marché si elle apparaît sur le graphique avant une correction ou à la fin de la tendance. Le doji sera plus significatif s'il apparaît sur une période plus large. Il existe de nombreux types et formations pour cette bougie et chacun dispose d'un grand nombre d'informations qui peuvent être utilisées en notre faveur dans le trading comme la Libellule (Dragonfly) et la Longue Jambe (Long-leg).

Ce que nous devons faire, c'est informer l'ordinateur pour qu'il détecte le motif Doji en définissant les prix et l'heure de la dernière bougie. A chaque tick, le programme doit vérifier et comparer ces valeurs à l'heure définie et déterminer les positions de chacun. Si l'ouverture est égale à la clôture, le programme doit renvoyer un signal indiquant qu'il s'agit d'une configuration de bougie de type Doji.

Nous devons maintenant créer un programme capable de détecter ce modèle. Voici les étapes d'une méthode permettant d'y parvenir :

Nous allons créer une fonction pour ce Doji (getDoji). Nous l'appellerons dans la fonction OnTick() pour chercher ce motif à chaque tick.

void OnTick()
  {
   getDoji();
  }

Créer la fonction getDoji qui retourne une variable entière

int getDoji()

Définir cette fonction en définissant l'heure, l'ouverture, le cours le plus élevé, le cours le plus bas et le cours de clôture de la dernière bougie.

Nous utiliserons la fonction iTime qui renvoie l'heure d'ouverture de la bougie, la fonction iOpen qui renvoie le prix d'ouverture de la bougie, la fonction iHigh qui renvoie le prix haut, la fonction iLow qui renvoie le prix bas, et la fonction iClose qui renvoie le prix de clôture de la bougie. Les paramètres sont les mêmes pour toutes ces fonctions :

symbol : pour définir le nom du symbole, nous utiliserons _Symbol pour le symbole actuel.
timeframe : pour définir la période du graphique, nous utiliserons PERIOD_CURRENT pour utiliser la période actuelle.
shift : pour définir l'indice de la valeur retournée, nous utiliserons 1 pour définir la dernière bougie.

   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);

Définition de la condition du Doji que nous devons détecter à l'aide de l'instruction if :

if(open==close)

Si cette condition est vraie, le programme doit créer un objet basé sur la fonction createObj que nous allons créer avec les paramètres de l’heure, du prix, du code de la flèche, de sa couleur et du texte dont nous avons besoin. Ensuite, la fonction se termine en renvoyant 1.

   if(open==close)
     {
      createObj(time,low,217, clrBlack,"Doji");
        {
         return 1;
        }
     }

Nous renverrons 0 pour mettre fin à la fonction de getDoji

   return 0;

Création de la fonction createObj avec les paramètres time, price, arrowcode, clr, et txt, qui ne retourne rien (void) :

void createObj(datetime time, double price, int arrawCode, color clr, string txt)

Création d'une variable de type chaîne de caractères objName à laquelle on affecte la valeur " "

string objName=" ";

Combiner les chaînes de caractères pour les affecter à la variable objName avec la fonction StringConcatenate qui forme une chaîne de caractères à partir des paramètres passés et renvoie la taille de la chaîne formée. Ses paramètres sont :

string_var : pour définir la chaîne qui sera formée après la concaténation, nous utiliserons la variable objName.
argument1 : pour définir le paramètre de n'importe quel type simple, nous utiliserons le texte "Signal at ".
argument2 : pour définir l'heure de la bougie détectée, nous utiliserons l'heure de la variable prédéterminée.
argument3 : nous mettrons le texte de " at ".
argument4 : nous allons définir le texte du prix arrondi en utilisant DoubleToString pour convertir le type double en type chaîne.
argument5 : nous mettrons le texte de " (".
argument6 : nous attribuerons une valeur à la variable entière arrowcode dont nous avons besoin. Ce code peut être trouvé en recherchant les caractères Wingdings dans la référence mql5.
argument7 : nous allons mettre le texte ")".

StringConcatenate(objName, "Signal at ",time, " at ",DoubleToString(price,_Digits)," (",arrawCode,")");

Nous allons définir une condition à évaluer avec l'instruction if et la fonction ObjectCreate comme expression. La fonction ObjectCreate crée un objet pour nous avec le nom objName. Ses paramètres sont :

chart_id : pour identifier le graphique, nous utiliserons 0 pour le graphique actuel.
name : pour définir le nom de l'objet, nous utiliserons le nom prédéfini de objName.
type : pour définir le type d'objet, nous utiliserons OBJ_ARROW.
nwin : pour définir le numéro de la sous-fenêtre du graphique, nous utiliserons 0 pour la fenêtre principale du graphique.
time1 : pour définir l'heure de l'ancre, nous utiliserons la variable prédéfinie time.
price1 : pour définir le prix de l'ancre, nous utiliserons la variable prédéfinie price.

if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))

Une fois que cette condition est remplie en créant l'objet, nous devons définir ses propriétés : sa forme avec le code de la flèche et sa couleur avec la fonction ObjectSetInteger qui définit la valeur d’une propriété de l'objet. Ses paramètres sont :

chart_id : pour identifier le graphique, nous utiliserons 0 pour le graphique actuel.
name : pour définir le nom de l'objet, nous utiliserons objName.
prop_id : pour définir la propriété de l'objet, nous utiliserons OBJPROP_ARROWCODE de l’énumération ENUM_OBJECT_PROPERTY_INTEGER pour le code de la flèche et OBJPROP_COLOR pour la couleur.
prop_value : pour définir la valeur de la propriété, nous utiliserons arrowCode pour le code de la flèche et la variable clr pour la couleur.

ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);

Ensuite, nous devons définir le texte dont nous avons besoin pour définir la bougie en créant une variable de type string pour la candleName avec une affectation des variables objName et txt.

string candleName=objName+txt;

Création et modification de l'objet texte à l'aide de l'instruction if et de la fonction ObjectCreate en tant qu'expression et de ObjectSetString comme opérateur pour définir la valeur de la chaîne de caractères de la propriété de l'objet et ObjectSetInteger pour définir la couleur de l'objet texte.

      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);

Maintenant, nous pouvons voir le code complet de cet Expert Advisor :

//+------------------------------------------------------------------+
//|                                        Doji pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getDoji();
  }
int getDoji()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
//Doji
   if(open==close)
     {
      createObj(time,low,217, clrBlack,"Doji");
        {
         return 1;
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal at ",time, " at ",DoubleToString(price,_Digits)," (",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Après avoir compilé ce code sans erreur, nous pouvons le trouver dans la fenêtre du Navigateur. En le faisant glisser pour qu'il soit exécuté, nous pouvons alors obtenir ses signaux détectant la figure Doji. Voici un exemple de test :

Exemple de Doji

Comme nous pouvons le voir dans le graphique précédent, nous avons une flèche noire sous la bougie et le texte Doji pour définir la configuration de la bougie.

Modèle Marteau (Hammer)

La figure du marteau est une figure de chandeliers très populaire que l'on peut voir sur le graphique dans de nombreuses périodes. Son nom fait référence à sa forme, car il a une longue ombre et un petit corps. Il existe 2 types de motifs de marteau : le marteau et le marteau inversé, en fonction de la position du petit corps. Si la bougie a une longue ombre inférieure et que le corps de la bougie est au-dessus, il s'agit d'une bougie de marteau qui peut être haussière ou baissière en fonction du prix d'ouverture et de clôture :

Marteau Haussier (Bullish Hammer)

Marteau Haussier

Cela indique que les vendeurs ont essayé de faire baisser le prix, mais que les acheteurs contrôlent le marché et clôturent à un niveau supérieur à celui de l'ouverture, ce qui est synonyme de force des acheteurs.

Marteau Baissier (Bearish Hammer)

Marteau Baissier

Cela indique que les vendeurs ont essayé de faire baisser le prix, mais que les acheteurs semblent clôturer à peu près au niveau de l'ouverture, ce qui signifie que les acheteurs sont toujours dans le jeu.

Si la bougie a une longue ombre supérieure et que son corps est en dessous, il s'agit d'un schéma de marteau inversé et il peut être haussier ou baissier en fonction de la position des prix d'ouverture et de clôture. Les figures suivantes sont des exemples de ce Marteau Inversé (Inverted Hammer).

Marteau Inversé Haussier (Bullish Inverted Hammer)

Marteau Inversé Haussier

Cela indique que les acheteurs ont essayé de pousser les prix à la hausse mais que les vendeurs semblent fermer la bougie autour de l'ouverture et du bas, ce qui signifie que les vendeurs sont toujours dans le jeu malgré la force des acheteurs.

Marteau Inversé Baissier (Bearish Inverted Hammer)

Marteau Inversé Baissier

Cela indique que les acheteurs ont essayé de faire baisser le prix, mais que les vendeurs contrôlent le marché et clôturent à un niveau inférieur à celui de l'ouverture, ce qui est synonyme de force des vendeurs.

Ce schéma, comme tous les schémas de chandeliers, sera plus significatif lorsqu'il sera combiné à d'autres outils techniques.

Maintenant, nous devons créer un programme qui peut être utilisé pour détecter ce type de schéma. Nous laisserons ce programme trouver les prix des bougies, l'heure, et la taille des bougies à comparer au corps et aux ombres de la bougie. Le programme doit vérifier continuellement et comparer les deux à chaque tick pour déterminer leurs positions. Lorsque le programme détecte un marteau ou un marteau inversé (haussier ou baissier), il doit créer un objet sur le graphique avec son nom de type et des flèches de couleur verte ou rouge basées sur la couleur de la bougie (haussière ou baissière) et au-dessus ou au-dessous de la bougie.

Voici le code complet pour créer ce type de programme :

//+------------------------------------------------------------------+
//|                                      Hammer pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getHammer(0.07,0.7);
  }
int getHammer(double smallShadowRatio, double longShadowRatio)
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double candleSize=high-low;
   if(open<close)
     {
      if(high-close < candleSize*smallShadowRatio)
        {
         if(open-low>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Hammer");
           {
            return 1;
           }
        }
     }
   if(open>close)
     {
      if(high-open<candleSize*smallShadowRatio)
        {
         if(close-low>candleSize*longShadowRatio)
            createObj(time,high,218,clrRed,"Hammer");
           {
            return 1;
           }
        }
     }
   if(open<close)
     {
      if(open-low < candleSize*smallShadowRatio)
        {
         if(high-close>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Inverted Hammer");
           {
            return -1;
           }
        }
     }
   if(open>close)
     {
      if(close-low < candleSize*smallShadowRatio)
        {
         if(high-open>candleSize*longShadowRatio)
            createObj(time,high,218, clrRed,"Inverted Hammer");
           {
            return -1;
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Les différences dans ce code sont les suivantes :

Appel de la fonction getHammer dans la fonction OnTick() en déterminant les paramètres souhaités pour smallShadowRatio et longShadowRatio :

void OnTick()
  {
   getHammer(0.07,0.7);
  }

Création de la fonction getHammer avec comme paramètres 2 variables de type double smallShadowRatio et longShadowRatio :

int getHammer(double smallShadowRatio, double longShadowRatio)

Création d'une variable de type double pour candleSize, à comparer au ratio :

double candleSize=high-low;

Conditions de la bougie Marteau :

Dans le cas d'un marteau haussier (ouverture < clôture), nous avons besoin d'une dernière bougie haussière : l'ombre supérieure de la bougie (plus haut - clôture) est inférieure au ratio de la petite ombre qui est de 0,07, et l'ombre inférieure (ouverture - plus bas) est supérieure au ratio de la longue ombre qui est de 0,7. Créez une flèche verte avec le code Wingdings 217 et l'objet texte "Hammer" sur le graphique en dessous du plus bas de cette bougie Marteau, puis terminez la fonction.

   if(open<close)
     {
      if(high-close < candleSize*smallShadowRatio)
        {
         if(open-low>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Hammer");
           {
            return 1;
           }
        }
     }

Dans le cas d'un marteau baissier (ouverture > clôture), il faut une dernière bougie baissière, l'ombre supérieure de la bougie (plus haut - ouverture) est inférieure au ratio de la petite ombre qui est de 0,07, et l'ombre inférieure (clôture - plus bas) est supérieure au ratio de la longue ombre qui est de 0,7. Créez une flèche rouge avec le code Wingdings 218 et l'objet texte "Hammer" sur le graphique au-dessus du sommet de cette bougie Marteau, puis terminez la fonction.

   if(open>close)
     {
      if(high-open<candleSize*smallShadowRatio)
        {
         if(close-low>candleSize*longShadowRatio)
            createObj(time,high,218,clrRed,"Hammer");
           {
            return 1;
           }
        }
     }

Dans le cas d'un marteau inversé haussier (ouverture < clôture), nous avons besoin d'une dernière bougie haussière, l'ombre inférieure de la bougie (ouverture - plus bas) est inférieure au ratio de la petite ombre qui est de 0,07, et l'ombre supérieure (plus haut - clôture) est supérieure au ratio de la grande ombre qui est de 0,7. Créez une flèche verte avec le code Wingdings 217 et l'objet texte "Marteau inversé" sur le graphique en dessous du plus bas de cette bougie Marteau, puis terminez la fonction.

   if(open<close)
     {
      if(open-low < candleSize*smallShadowRatio)
        {
         if(high-close>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Inverted Hammer");
           {
            return -1;
           }
        }
     }

Dans le cas d'un marteau inversé baissier (ouverture > clôture), il faut une dernière bougie baissière, l'ombre inférieure de la bougie (clôture - plus bas) est inférieure au ratio de la petite ombre qui est de 0,07, et l'ombre supérieure (plus haut - ouverture) est supérieure au ratio de la longue ombre qui est de 0,7. Créez une flèche rouge avec le code Wingdings 218 et l'objet texte "Marteau inversé" sur le graphique au-dessus du sommet de cette bougie, puis terminez la fonction.

   if(open>close)
     {
      if(close-low < candleSize*smallShadowRatio)
        {
         if(high-open>candleSize*longShadowRatio)
            createObj(time,high,218, clrRed,"Inverted Hammer");
           {
            return -1;
           }
        }
     }

Modifions la position et la couleur de la flèche en fonction du type de bougie à l'aide de l'opérateur "if". L'expression sera la couleur, et l'opérateur "if" (s'il est vrai) sera utilisé comme position de la flèche à l'aide de la fonction ObjectSetInteger.

Si le vert est en dessous de la bougie

      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);

Si le rouge est au-dessus de la bougie

      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);

Après avoir compilé ce code sans erreur et l'avoir exécuté, nous pouvons obtenir notre signal. Les exemples suivants sont tirés des tests :

Marteau Haussier (Bullish Hammer) :

Exemple de Marteau Haussier

Comme nous pouvons le voir, nous avons une flèche verte et l'objet texte "Hammer" vert sur le graphique en dessous du bas de la bougie Marteau Haussier.

Marteau Baissier (Bearish Hammer) :

Exemple de Marteau Baissier

Comme nous pouvons le voir, nous avons une flèche rouge et l'objet texte "Hammer" rouge sur le graphique au-dessus du sommet de la bougie Marteau Baissier.

Marteau Inversé Haussier (Bullish Inverted Hammer) :

Exemple de Marteau Inversé Haussier

Comme nous pouvons le voir, nous avons une flèche verte et l'objet texte vert "Inverted Hammer" sur le graphique en dessous du bas de la bougie du Marteau Inversé Haussier.

Marteau Inversé Baissier (Bearish Inverted Hammer) :

Exemple de Marteau Inversé Baissier

Comme nous pouvons le voir, nous avons une flèche rouge et l'objet texte rouge "Inverted Hammer" sur le graphique au-dessus du sommet de la bougie baissière en forme de marteau inversé.

Modèle à 2 bougies

Dans cette partie, nous verrons un autre type de schéma de chandelier constitué de 2 bougies. Nous verrons deux schémas populaires qui sont l’Engouffrement (Engulfing), Haussier et Baissier, et le Piercing line haussier et son opposé le Dark Cloud baissier.

Modèle d'Engloutissement

Cette configuration de chandelier est également très populaire sur les graphiques et dans l'analyse technique. Elle consiste en deux bougies dont l'une engloutit l'autre, ce qui signifie qu'il y a une petite bougie suivie d'une plus grande et que cette dernière recouvre complètement la plus petite. On parle indistinctement d’Engloutissement, d’Engouffrement ou d’Avalement.

Il existe plusieurs types de figures d'Engloutissement en fonction de la couleur ou du type de bougies :

L'Engloutissement Haussier (Bullish Engulfing) :

Une petite bougie baissière est suivie d'une grande bougie haussière, et cette bougie haussière engloutit la petite bougie, ce qui explique la figure suivante :

Engloutissement Haussier

Selon son importance, il indique que les acheteurs contrôlent le marché et que le prix peut continuer à augmenter.

L’Engloutissement Baissier (Bearish Engulfing) :

Une petite bougie haussière est suivie d'une grande bougie baissière, et cette dernière engloutit la petite bougie haussière, ce qui explique la figure suivante :

Engloutissement Baissier

Selon son importance, il indique que les vendeurs contrôlent le marché et que le prix peut continuer à baisser.

Maintenant, si nous voulons créer un programme qui peut être utilisé pour détecter ce schéma automatiquement, nous devons définir l'heure de la dernière bougie et les prix des deux dernières bougies. Le programme doit vérifier continuellement ces valeurs à chaque tick et déterminer ces positions les unes par rapport aux autres pour vérifier si un Engloutissement se produit ou non. Une fois que nous avons obtenu cette figure d'Engloutissement, le programme doit renvoyer un signal spécifique : une flèche colorée et un objet texte en fonction de son type (haussier ou baissier).

Voici le code complet pour créer ce programme :

//+------------------------------------------------------------------+
//|                                   Engulfing pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getEngulfing();
  }
int getEngulfing()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   if(open<close)
     {
      if(open2>close2)
        {
         if(high>high2&&low<low2)
           {
            if(close>open2&&open<close2)
              {
               createObj(time,low,217, clrGreen,"Bullish Engulfing");
                 {
                  return 1;
                 }
              }
           }
        }
     }
   if(open>close)
     {
      if(open2<close2)
        {
         if(high>high2&&low<low2)
           {
            if(close<open2&&open>close2)
              {
               createObj(time,high,218, clrRed,"Bearish Engulfing");
                 {
                  return -1;
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Voici les différences dans ce code :

Création de variables de type double à l’heure de la dernière bougie et aux prix des deux dernières bougies pour la création via la fonction getEngulfing, time, open, high, low et close sont pour la dernière bougie et open2, high2, low2 et close2 sont pour la bougie précédente.

   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);

Conditions qui définissent ce type de bougie

Dans le cas du Bullish Engulfing, la dernière bougie est haussière (open < close), l'avant-dernière est baissière (open2 > close2), high est supérieur à high2 et low est inférieur à low2, close est supérieur à open2 et open est inférieur à close2. Après l'avoir identifiée, créez un objet avec la fonction créée createObj avec les paramètres suivants :

time : il s'agit de l'heure de la dernière bougie, qui est la variable prédéfinie.
price : ce sera le plus bas de la dernière bougie sous laquelle nous voulons placer l'objet.
arrowCode : il s'agit du code 217 des caractères Wingdings.
clr : ce sera clrGreen.
txt : ce sera "Bullish Engulfing".

Ensuite, la fonction s'arrête.

   if(open<close)
     {
      if(open2>close2)
        {
         if(high>high2&&low<low2)
           {
            if(close>open2&&open<close2)
              {
               createObj(time,low,217, clrGreen,"Bullish Engulfing");
                 {
                  return 1;
                 }
              }
           }
        }
     }

Dans le cas du Bearish Engulfing, la dernière bougie est baissière (open > close), la précédente est haussière (open2 < close2), high est supérieur à high2, et low est inférieur à low2, close est inférieur à open2 et open est supérieur à close2. Après l'avoir identifiée, créez un objet avec la fonction créée createObj avec les paramètres suivants :

time : il s'agit de l'heure de la dernière bougie, qui est la variable prédéfinie.
price : ce sera le plus haut de la dernière bougie au-dessus de laquelle nous voulons que l'objet soit placé.
arrowCode : il s’agit du code 218 des caractères Wingdings.
clr : ce sera clrRed.
txt : ce sera "Bearish Engulfing".

Ensuite, la fonction s'arrête.

   if(open>close)
     {
      if(open2<close2)
        {
         if(high>high2&&low<low2)
           {
            if(close<open2&&open>close2)
              {
               createObj(time,high,218, clrRed,"Bearish Engulfing");
                 {
                  return -1;
                 }
              }
           }
        }
     }

Après avoir compilé ce code sans erreurs et exécuté son EA, ses signaux sont obtenus comme dans les exemples suivants à partir des tests :

L'Engloutissement Haussier (Bullish Engulfing) :

Exemple d'Engloutissement Haussier

Comme nous pouvons le voir sur le graphique précédent, nous avons une flèche verte et un texte d'Engloutissement Haussier « Bullish Engulfing » sous le plus bas de la dernière bougie de la figure.

L’Engloutissement Baissier (Bearish Engulfing) :

Exemple d'Engloutissement Baissier

Comme nous pouvons le voir sur le graphique précédent, nous avons une flèche rouge et un texte Bearish Engulfing au-dessus du plus haut de la dernière bougie de la figure.

Ligne de Perçage (Piercing Line) et motif de la Couverture Nuageuse Sombre (Dark Cloud Cover) :

Motif Ligne de Perçage (Piercing Line) :

Il s'agit d'un chandelier haussier composé de 2 bougies : la première est baissière et suivie d'une bougie haussière dont l'ouverture est plus basse que celle de la bougie baissière, puis qui remonte et ferme au-dessus du point médian de la première bougie baissière. La figure suivante le décrit :

Ligne de perçage

Cela indique que les acheteurs deviennent plus forts et contrôlent le marché après avoir pris le contrôle des vendeurs. Il s'agit donc du passage de la puissance des vendeurs aux acheteurs, les acheteurs ayant réussi à faire passer le prix au-dessus du point médian de la bougie baissière précédente, bien qu'il y ait eu un écart lors de l'ouverture.

Modèle de Couverture Nuageuse Sombre (Dark Cloud Cover) :

Il s'agit d'une configuration baissière comportant 2 bougies : la première est haussière et est suivie d'une bougie baissière avec un écart d'ouverture et une clôture en dessous du point médian de la première bougie haussière. Le graphique suivant l’illustre :

Couverture Nuageuse Sombre

Cela indique que les vendeurs deviennent plus forts et contrôlent le marché. Il s'agit donc d'un passage de la puissance des acheteurs à la puissance des vendeurs, les vendeurs ayant réussi à pousser le prix en dessous du point médian de la bougie haussière précédente, bien qu'il y ait eu un écart lors de l'ouverture.

Lorsque nous voulons créer un programme qui peut être utilisé pour détecter ce type de schéma, nous devons définir l'heure et les prix de la première bougie (heure, ouverture, haut, bas et clôture) et les prix de la deuxième bougie (ouverture2, haut2, bas2 et clôture2), la taille de la première bougie (taille2) et le point médian de la première bougie (point médian2). Le programme doit vérifier continuellement ces valeurs et déterminer leurs positions l'une par rapport à l'autre pour renvoyer un signal basé sur des conditions spécifiques suivant le caractère haussier ou baissier.

Voici le code complet pour créer ce programme :

//+------------------------------------------------------------------+
//|                      Piercing && Dark Cloud pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getPiercing();  
  }
int getPiercing()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double candleSize2=high2-low2;
   double candleMidPoint2=high2-(candleSize2/2);
   if(open<close)
     {
      if(open2>close2)
        {
         if(open<low2)
           {
            if(close>candleMidPoint2&&close<high2)
              {
               createObj(time,low,217, clrGreen,"Piercing");
                 {
                  return 1;
                 }
              }
           }
        }
     }
   if(open>close)
     {
      if(open2<close2)
        {
         if(open>high2)
           {
            if(close<candleMidPoint2&&close>low2)
              {
               createObj(time,high,218, clrRed,"Dark Cloud");
                 {
                  return -1;
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Différences dans ce code

Définition de candleSize2 et candleMidPoint2

   double candleSize2=high2-low2;
   double candleMidPoint2=high2-(candleSize2/2);

Conditions du modèle

Dans le cas du motif "Piercing Line" :

Si la dernière bougie est haussière (open < close), et que open2 est supérieur à close2, que open est inférieur à low2, et que close est supérieur à candleMidPoint2, et en même temps close est inférieur à high2, le programme doit d’abord renvoyer un objet sur le graphique avec une flèche verte et le texte "Piercing" sous le bas de la figure, puis terminer la fonction.

   if(open<close)
     {
      if(open2>close2)
        {
         if(open<low2)
           {
            if(close>candleMidPoint2&&close<high2)
              {
               createObj(time,low,217, clrGreen,"Piercing");
                 {
                  return 1;
                 }
              }
           }
        }
     }

Dans le cas de la Couverture Nuageuse Sombre (Dark Cloud Cover) :

Si la dernière bougie est baissière (open > close), et que open2 est inférieur à close2, que open est supérieur à high2, que close est inférieur à candleMidPoint2 et que close est supérieur à low2, le programme doit d’abord renvoyer un objet sur le graphique avec une flèche rouge et le texte "Dark Cloud" au-dessus du high de la figure, puis terminer la fonction.

   if(open>close)
     {
      if(open2<close2)
        {
         if(open>high2)
           {
            if(close<candleMidPoint2&&close>low2)
              {
               createObj(time,high,218, clrRed,"Dark Cloud");
                 {
                  return -1;
                 }
              }
           }
        }
     }

Après avoir compilé ce code et exécuté l’EA, les signaux souhaités sont obtenus comme dans les exemples de test suivants :

Modèle de Ligne de Perçage (Piercing Line) :

Exemple de Ligne de Perçage

Comme nous pouvons le voir dans le graphique précédent, nous avons notre flèche verte et le texte de percée sous le plus bas de la configuration, comme nous en avons besoin.

Modèle de Couverture Nuageuse Sombre (Dark Cloud Cover) :

Exemple de Couverture Nuageuse Sombre

Comme nous pouvons le voir dans le graphique précédent, nous avons une flèche rouge et un texte de nuage sombre au-dessus du sommet de la figure, comme nous en avons besoin.

Modèle à 3 bougies

Dans cette partie, nous verrons deux motifs parmi les motifs mélangés, à savoir le motif de l'Etoile (du matin, du soir) et le motif des Trois à l’Intérieur (Hausse, Baisse).

Motif de l'Etoile (Start) :

L'Etoile du Matin :

Il s'agit d'une structure à 3 bougies, comme celle que nous avons mentionnée. Elle est formée par une petite bougie entre deux bougies : la première est une longue bougie baissière et la seconde est une longue bougie haussière. Le graphique suivant l’illustre :

Étoile du Matin

Ce motif indique un changement de pouvoir de la vente à l'achat, les acheteurs contrôlant le marché et poussant le prix à la hausse après une baisse due au contrôle des vendeurs.

Motif de l'Etoile du Soir :

Il s'agit d'une structure à trois bougies, comme celle que nous avons mentionnée. Elle est formée par une petite bougie entre deux bougies : la première est une longue bougie haussière et la seconde est une longue bougie baissière. Le graphique suivant en est une illustration :

Étoile du Soir

Ce motif indique un changement de pouvoir de l'achat vers la vente, les vendeurs contrôlant le marché et poussant le prix à la baisse après une reprise par le contrôle des acheteurs.

Lorsque nous voulons créer un programme qui peut être utilisé pour détecter ce type de schéma, nous devons définir l'heure et le prix de la dernière bougie et les données de prix des deux bougies précédentes de la dernière, la taille des trois dernières bougies et les comparer les uns aux autres pour déterminer leurs positions les uns par rapport aux autres afin d'obtenir des signaux spécifiques basés sur des conditions spécifiques.

Voici le code complet pour créer ce programme :

//+------------------------------------------------------------------+
//|                                        Star pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
void OnTick()
  {
   getStar(0.5);
  }
int getStar(double middleCandleRatio)
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   double candleSize=high-low;
   double candleSize2=high2-low2;
   double candleSize3=high3-low3;
   if(open<close)
     {
      if(open3>close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,low,217, clrGreen,"Morning Star");
              {
               return 1;
              }
           }
        }

     }
   if(open>close)
     {
      if(open3<close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,high,218, clrRed,"Evening Star");
              {
               return -1;
              }
           }
        }

     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Différences dans ce code

Création de getStar avec le paramètre middleCandleRatio

int getStar(double middleCandleRatio)

Création de variables pour l’heure de la dernière bougie et pour les données de prix (open, high, low, close), et la taille de bougie pour les trois dernières bougies (candlesize, candleSize2, et candleSize3).

   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   double candleSize=high-low;
   double candleSize2=high2-low2;
   double candleSize3=high3-low3;

Conditions du modèle

Dans le cas du modèle Etoile du Matin (Morning Star) :

Si la dernière bougie est haussière (open < close), la troisième est baissière (open3 > close3), candleSize2 est inférieur à middleCandleRatio de candleSize qui est de 0.5, et en même temps candleSize2 est inférieur à middleCandleRatio de candleSize3, le programme doit renvoyer une flèche verte et le texte de "Morning Star" en dessous du bas de la figure, puis terminer la fonction.

   if(open<close)
     {
      if(open3>close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,low,217, clrGreen,"Morning Star");
              {
               return 1;
              }
           }
        }
     }

Dans le cas de l'Etoile du Soir :

Si la dernière bougie est baissière (open > close), la troisième est haussière (open3 < close3), candleSize2 est inférieur à middleCandleRatio de candleSize qui est de 0.5, et en même temps candleSize2 est inférieur à middleCandleRatio de candleSize3, le programme doit renvoyer une flèche rouge et le texte de "Evening Star" au-dessus du plus haut de la figure, puis terminer la fonction.

   if(open>close)
     {
      if(open3<close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,high,218, clrRed,"Evening Star");
              {
               return -1;
              }
           }
        }
     }

Après avoir compilé ce code sans erreur et exécuté son EA, nous obtenons des signaux identiques aux exemples suivants issus des tests :

L'Etoile du Matin :

Exemple d'Etoile du Matin

Comme nous pouvons le voir, nous avons le signal désiré sur le graphique en dessous du motif détecté.

L'Etoile du Soir :

Exemple d'Etoile du Soir

Comme nous pouvons le voir, nous avons le signal désiré sur le graphique en dessous du motif détecté.

Vous pouvez ajouter cette condition dans le code, si vous souhaitez obtenir un schéma identique.

Motif Trois à l’Intérieur :

Trois Hausse à l'Intérieur (Three Inside Up) :

La première bougie est une longue bougie baissière, la deuxième est une petite bougie haussière qui se négocie à l'intérieur de la première, et la troisième est une longue bougie haussière qui clôture au-dessus du sommet de la première bougie. Le graphique suivant illustre cette tendance :

Trois Hausse à l'Intérieur

Ce motif indique une hausse potentielle du contrôle par les acheteurs.

Trois Baisse à l’Intérieur (Three Inside Down) :

La première bougie est une longue bougie haussière, la deuxième est une petite bougie baissière qui se négocie à l'intérieur de la première, et la troisième est une longue bougie baissière qui clôture en dessous du plus bas de la première bougie. Le graphique suivant illustre cette tendance :

Trois Baisse à l'Intérieur

Ce motif indique un potentiel baissier du contrôle par les vendeurs. Si nous voulons créer un programme qui peut être utilisé pour détecter ce type de schéma, nous définirons également l'heure de la dernière bougie et les prix des trois dernières bougies, nous laisserons le programme vérifier ces valeurs à chaque tick et déterminer ses positions les unes par rapport aux autres pour renvoyer un signal approprié sous la forme d'un objet sur le graphique en fonction du schéma. Voici le code complet de ce programme :

//+------------------------------------------------------------------+
//|                                Three inside pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
void OnTick()
  {
   getthreeInside();
  }
int getthreeInside()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   if(open3>close3)
     {
      if(open2<close2)
        {
         if(open2>low3&&close2<high3)
           {
            if(open<close&&open>open2&&open<close2)
              {
               if(close>high3)
                 {
                  createObj(time,low,217, clrGreen,"3 Inside Up");
                    {
                     return 1;
                    }
                 }
              }
           }
        }

     }
   if(open3<close3)
     {
      if(open2>close2)
        {
         if(open2<high3&&close2>low3)
           {
            if(open>close&&open<open2&&open>close2)
              {
               if(close<low3)
                 {
                  createObj(time,high,218, clrRed,"3 Inside Down");
                    {
                     return -1;
                    }
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Les différences dans ce code sont les conditions du modèle

Dans le cas de Three Inside Up

   if(open3>close3)
     {
      if(open2<close2)
        {
         if(open2>low3&&close2<high3)
           {
            if(open<close&&open>open2&&open<close2)
              {
               if(close>high3)
                 {
                  createObj(time,low,217, clrGreen,"3 Inside Up");
                    {
                     return 1;
                    }
                 }
              }
           }
        }

     }

Dans le cas du Three Inside Down

   if(open3<close3)
     {
      if(open2>close2)
        {
         if(open2<high3&&close2>low3)
           {
            if(open>close&&open<open2&&open>close2)
              {
               if(close<low3)
                 {
                  createObj(time,high,218, clrRed,"3 Inside Down");
                    {
                     return -1;
                    }
                 }
              }
           }
        }
     }

Après avoir compilé ce code sans erreur et exécuté son EA, nous pouvons obtenir des signaux identiques aux exemples suivants :

Trois Hausse à l'Intérieur (Three Inside Up) :

Exemple Trois Hausse à l'Intérieur

Comme nous pouvons le voir sur le graphique, nous avons le signal souhaité du Three Inside Up.

Trois Baisse à l’Intérieur (Three Inside Down) :

Exemple Trois Baisse à l’Intérieur

Comme nous pouvons le voir sur le graphique, nous avons le signal souhaité du Three Inside Down.

Conclusion

Vous avez maintenant une idée de la façon d'écrire le code pour détecter les motifs de bougies dans leurs différentes formations, bougies simples, motifs à 2 et à 3 bougies :

Signaux de bougies : nous avons appris à détecter les motifs Doji et Hammer.
Les figures à deux bougies : nous avons appris à détecter les figures d'Engulfing, de Piecing Line et de Dark Cloud Cover.
Les motifs à trois bougies : nous avons appris à créer un programme capable de détecter les Etoiles et les motifs à trois bougies.

J'espère que cet article vous sera utile pour vous aider à mieux comprendre la situation.

Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/12385

Fichiers joints |

Télécharger ZIP

Doji_pattern_detector.mq5 (1.42 KB)

Hammer_pattern_detector.mq5 (2.75 KB)

Engulfing_pattern_detector.mq5 (2.37 KB)

Piercing_ss_Dark_Cloud_pattern_detector.mq5 (2.44 KB)

Star_pattern_detector.mq5 (3.32 KB)

Three_inside_pattern_detector.mq5 (2.88 KB)

Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Derniers commentaires | Aller à la discussion (1)

Adams.16 | 8 déc. 2024 à 10:55

Merci beaucoup. Votre travail permet d'adhérer à la tendance et d'analyser avec la plus grande confiance possible... Je travaille depuis un moment sur un motif de deux bougies ou plus, jusqu'à 5, qui peuvent se suivre en respectant. les conditions. Je définirais le motif en dessinant un rectangle dessus à chaque fois qu'il apparaissait. Après avoir regardé votre sujet util, j'ai remplacé le rectangle par le signal, et l'indicateur était plus rapide. Mais tout comme j'ai échoué avec le rectangle, j'ai également échoué avec le signal : je n'ai pas réussi à déterminer le temps du signal actuel comme fin d'un niveau Fibo qui part du temps du signal précédent. le niveau sera rayon si on est au dernier signal. S'il vous plaît, aidez-moi à mettre fin à mes souffrances liées à ce problème, que Dieu vous bénisse.Si vous pouviez m'aider s'il vous plaît donnez moi un exemple sur le modèle d'engolfing avec high et Low comme 0 et 100.Que Dieu te récompense.

Attentes morales dans le trading

Cet article est consacré aux attentes morales. Nous examinerons plusieurs exemples de son utilisation dans le trading, ainsi que les résultats qui peuvent être obtenus grâce à cela.

Apprenez à concevoir un système de trading basé sur les Retracements de Fibonacci

Dans cet article, nous poursuivons notre série sur la création d'un système de trading basé sur les indicateurs techniques les plus populaires. Voici un nouvel outil technique : les Retracements de Fibonacci. Nous allons apprendre à concevoir un système de trading basé sur cet indicateur technique.

Comment choisir un Expert Advisor : Vingt critères solides pour rejeter un robot de trading

Cet article tente de répondre à la question suivante : comment choisir les bons Experts Advisors ? Quels sont les meilleurs pour notre portefeuille, et comment pouvons-nous filtrer la grande liste de robots de trading disponibles sur le marché ? Cet article présente 20 critères clairs et solides pour rejeter un Expert Advisor. Chaque critère sera présenté et bien expliqué pour vous aider à prendre une décision plus soutenue et à construire une collection d’Experts Advisors plus rentable pour vos profits.

Figures et exemples (partie I) : Multiple Top, ou Hauts Multiples

Cet article est le premier d'une série consacrée aux figures (ou motifs, modèles, patterns) d'inversion dans le cadre du trading algorithmique. Nous commencerons par la famille de modèles la plus intéressante, qui trouve son origine dans les modèles Double Top et Double Bottom.