Les indicateurs des tendances micro, moyenne et principale

Introduction

Dans la préface de son livre"Pattern, Price & Time: Utiliser la théorie de Gann dans les systèmes de trading" James Hyerczyk a écrit :

"Mon expérience dans le secteur des contrats à terme m'a montré que trop souvent les traders deviennent accros au modèle, au prix ou au temps dans leur analyse. Ils ont tendance à pondérer leur analyse dans un sens sans équilibre égal. Les erreurs les plus courantes sont les systèmes construits autour du temps d'entrée et du prix de sortie, ou du prix d'entrée et du temps de sortie. De plus, les traders qui utilisent des modèles entrent ou sortent souvent à des prix médiocres ou avec un mauvais timing. Ces observations ont fourni une preuve supplémentaire qu'une combinaison des trois méthodes est nécessaire pour réussir sur le marché. C'est sur cette prémisse que j'ai basé mon livre."

On ne peut pas être d'accord avec cette affirmation. Essayons de comprendre comment utiliser certaines de ces méthodes dans la pratique. L’objet de cet article est d'étudier la possibilité d'automatisation du trade et l'analyse, sur la base de certaines des idées décrites dans le livre, sous forme d'indicateurs et d' EA. Par conséquent, pour mieux comprendre la documentation, il est recommandé de lire le livre (ou au moins la première partie - le modèle) avant de lire cet article.

1.1 La Micro Tendance

Le graphique d'une tendance mineure est illustré en figure 1. Examinons brièvement les règles de construction d'une tendance mineure :

• lors d'un mouvement ascendant (lorsque le maximum de la barre suivante est supérieur au maximum de la barre précédente, et que le minimum de la barre suivante est supérieur au minimum de la barre précédente), on relie le maximum suivant de la barre avec le précédent, et obtenez une ligne de la tendance à la hausse ;
• lors d'un mouvement descendant (lorsque le minimum de la barre suivante est inférieur au minimum de la barre précédente, et le maximum de la barre suivante est inférieur au maximum de la barre précédente) connecter le minimum suivant de la barre avec le précédent , et obtenez une ligne de la tendance à la baisse ;
• si lors d'un mouvement ascendant, le maximum d'une autre barre n'a pas dépassé le maximum de la barre précédente et, ainsi, le minimum de la barre suivante est inférieur à celui de la barre précédente, alors le sens du mouvement a été changé vers le bas;
• si lors d'un mouvement descendant, le minimum de la barre suivante n'est pas inférieur au minimum de la barre précédente, et en même temps, le maximum de la barre suivante est supérieur au maximum de la barre précédente, alors la direction est passée vers le haut ;
• Si, pour tout mouvement, le minimum de la barre suivante est supérieur au minimum de la barre précédente, et en même temps, le maximum de la barre suivante est inférieur au maximum de la précédente, alors cette barre est appelée inside (voir Fig.1) et ne contribue pas à la construction du graphe ;
• Si lors d'un quelconque mouvement, le maximum de la barre suivante est supérieur au maximum de la barre précédente, et en même temps, le minimum de la barre suivante est inférieur au minimum de la barre précédente, alors cette barre est appelée outside ( voir figure 1). En fonction du sens de la barre (vers le haut ou vers le bas), on construit le segment correspondant du graphe.

Figure 1. Tendances mineures

Lorsque la direction du mouvement du graphique est modifiée, il se forme ce que l'on appelle despics et creux mineurs. Les ceux mineurs de la figure 1 sont marqués par l'étiquette de prix de gauche en rouge, et les pics mineurs sont marqués par l'étiquette de prix de droite en vert.

Si, lors du mouvement ascendant, la direction est passée à la baisse, mais n'a pas atteint le dernier creux, alors nous avons un mouvement correctif. Sinon, il y a eu un changement de direction. Il en est de même pour le mouvement descendant.

Ainsi, le prix évolue entre les creux et les sommets. De tels mouvements sont appelésswings. Dans le même temps, des mouvements correctifs peuvent être générés.

Voici les règles en bref, pour construire la ligne indicatrice de la micro tendance. Une description plus détaillée se trouve dans la première partie du livre. Le graphique de cet indicateur ressemble au graphique d'un indicateur ZigZag bien connu. Mais contrairement à lui, il n'est pas retracé après la clôture d'une autre barre, et n'a pas de paramètres réglables externes qui affectent la construction de la ligne.

1.2. L'Indicateur GannMicroTrend

Élaborons un indicateur qui affichera le graphique de la micro tendance. L'apparence doit être la même que dans la Figure 1. Ajoutons également la sortie à l'affichage de la dernière position des pics et des ceux, par rapport au temps. Cet indicateur se trouve dans le fichier GannMicroTrend.mq5, joint à cet article.

Pour afficher ces informations, utilisez la bibliothèque, décrite dans l'articleCréer votre propre Veille de Marché à l’aide des Classes de Bibliothèque Standard. Pour cela, au début du texte de notre indicateur, ajoutez l’instruction #include :

#include  <TextDisplay.mqh>

Il est admis que le fichier ci-dessus se trouve dans le dossier \MQL5\Include.

L'indicateur doit stocker dans les variables globales les paramètres de l’actuelle tendance et les paramètres des derniers pics et creux. De plus, il devrait y avoir la possibilité d’indiquer la profondeur du calcul pour le nombre de barres donné dans l'historique.

Pour le faire, ajoutez les paramètres externes spécifiés :

input int     MaxBars = 1000;
input bool    IsSaveTrendParams = true;
//---------------------------------------------------------------------
input bool    ShowInfo = true;
input int     UpDownInfoShift = 1;
input int     LeftRightInfoShift = 1;
input color   TitlesColor = LightCyan;
input color   TopFieldsColor = Green;
input color   LowFieldsColor = Brown;
//---------------------------------------------------------------------
input color   UpTrendColor = LightGreen;
input color   DnTrendColor = LightPink;
input int     LineWidth = 4;
//---------------------------------------------------------------------
input color   UpStopLossColor = Green;
input color   DnStopLossColor = Brown;
input int     StopLossWidth = 1;

Le but de ces paramètres est indiqué dans le tableau suivant :

Le nom du paramètre	Le but du paramètre
MaxBars	Le nombre maximum de barres dans l'historique, auquel l'indicateur est tracé. Si c'est 0, alors toutes les barres disponibles dans l'historique sont comptées et tracées.
IsSaveTrendParams	Si vrai, les paramètres de l’actuelle tendance et les paramètres des derniers pics et creux sont stockés dans les variables globales.
ShowInfo	Si vrai, la fenêtre graphique affiche les coordonnées des derniers pics et creux.
UpDownInfoShift	Un décalage vertical de haut en bas du lieu de sortie de l'information.
LeftRightInfoShift	Un décalage horizontal de gauche à droite du lieu en cas de sortie d'informations.
TitlesColor	La couleur des en-têtes lors de la sortie des informations.
TopFieldsColor	La couleur du texte lors de la sortie des paramètres du dernier pic.
LowFieldsColor	La couleur du texte lors de la sortie des derniers creux.
UpTrendColor	La couleur du tracé au trait du mouvement ascendant.
DnTrendColor	La couleur du tracé au trait du mouvement descendant.
LineWidth	La largeur des lignes de tendance.
UpStopLossColor	La couleur de la bonne étiquette de prix, indiquant les pics.
DnStopLossColor	La couleur de l'étiquette de prix de gauche, indiquant les ceux
StopLossWidth	La taille de l'étiquette de prix, indiquant les sommets et les creux.

Nous allons construire la ligne de tendance, en utilisant les objets graphiques de type CChartObjectTrend. à partir de l'ensemble des classes standard. Les pics secondaires seront marqués par l'étiquette de prix de gauche - par les objets de type CChartObjectArrowLeftPrice, tandis que les creux secondaires - par les objets de type CChartObjectArrowRightPrice. Tous ces objets sont contenus dans les classes de bibliothèque standard fournies avec le terminal MetaTrader 5.

Puisqu'à l'avenir nous devrons manipuler les lignes de tendance, ainsi que les pics/creux, nous les stockerons dans une liste d'objets de type CList,, également à partir d'un ensemble de classes standard. Pour cela, ajoutez au début de l'indicateur les instructions d'inclusion des fichiers d'en-tête :

#include  <Arrays\List.mqh>
#include  <ChartObjects\ChartObjectsLines.mqh>
#include  <ChartObjects\ChartObjectsArrows.mqh>

Ensuite, ajoutez les listes d'objets :

CList*  trend_list_Ptr = NULL;  // list of the trend lines
CList*  up_list_Ptr = NULL;     // list of the peaks
CList*  dn_list_Ptr = NULL;     // list of the bottoms

Nous avons maintenant tous les éléments nécessaires à la construction de l'indicateur.

La fonction OnInit de l'indicateur est la suivante :

int OnInit()
{
  trend_list_Ptr = new CList();
  if(CheckPointer(trend_list_Ptr) != POINTER_DYNAMIC)
  {
    Print("Error of creating the object CList #1");
    return(-1);
  }

  up_list_Ptr = new CList();
  if(CheckPointer(up_list_Ptr) != POINTER_DYNAMIC)
  {
    Print("Error of creating the obkect CList #2");
    return(-1);
  }

  dn_list_Ptr = new CList();
  if(CheckPointer(dn_list_Ptr) != POINTER_DYNAMIC)
  {
    Print("Error of creating the object CList #3");
    return(-1);
  }

  if(InitGraphObjects() != 0)
  {
    Print("Error of creating the object TableDisplay");
    return(-1);
  }

  return(0);
}

Ici sont créés les pointeurs vers les listes d'objets, puis le succès de la création est vérifié. Si le pointeur n'est pas valide, alors un message d'erreur est reçu et avec cela, le travail de l'indicateur est achevé. L'endroit où l'erreur s'est produite peut être identifié par le numéro avec le caractère # Ensuite, le tableau d'affichage des paramètres des derniers pics et creux est initialisé. Cela se fait dans le code de fonction InitGraphObjects..

La partie principale de notre indicateur - est le gestionnaire d'événements sur la nécessité d'effectuer des calculs. C'est la fonction OnCalculate. Examinons-le pièce par pièce. La première partie - la vérification de la nécessité de recalculer toute la partie affichée de l'indicateur. Un tel besoin apparaît, par exemple, lorsque l'indicateur est démarré pour la première fois sur le graphique, lors du téléchargement d'un historique mis à jour sur le graphique, lorsqu'un changement dans la période de temps s'est produit. Dans tous ces cas, la valeur de l'argument prev_calculated est égale à zéro.

Cela se vérifie de la manière suivante :

int index, start = prev_calculated - 1;

if(prev_calculated == 0)
{
  if(CheckPointer(trend_list_Ptr) != POINTER_INVALID)
  {
    trend_list_Ptr.Clear();
  }
  if(CheckPointer(up_list_Ptr) != POINTER_INVALID)
  {
    up_list_Ptr.Clear();
  }
  if(CheckPointer(dn_list_Ptr) != POINTER_INVALID)
  {
    dn_list_Ptr.Clear();
  }

//  Determine the bar number of the beginning of calculations:
  if(MaxBars > 0 && rates_total > MaxBars)
  {
    start = rates_total - MaxBars;
  }
  else
  {
    start = 0;
  }
  time_prev = 0;
  trend_prev = 0;
}

S'il est nécessaire de recalculer l'ensemble de l'indicateur, alors nous effaçons la liste des lignes de tendance et les listes des pics/creux. De plus, ces objets graphiques sont également supprimés du graphique. Ensuite, nous déterminons le numéro de la barre à partir de laquelle nous devons commencer le calcul de l'indicateur - la variable de start Si la valeur de la variable externe MaxBars est supérieure à zéro et inférieure au nombre de barres sur le graphiquerates_total , alors la barre de départ du calcul sera égale à :

    start = rates_total - MaxBars;

Rappelons que l'indexation des barres d'unetime-series part de zéro (la barre récente).

Si la valeur de la variable externe MaxBars est égale à zéro (ce qui signifie - nous devons calculer l'indicateur sur toutes les barres du graphique) ou supérieure au nombre de barres sur le graphique, alors nous devons recalculer toutes les valeurs ​​de l'indicateur pour toutes les barres du graphique, c'est-à-dire que lestart est égal à zéro.

Ensuite, il y a un cycle de calcul de la ligne de tendance et des positions des pics/creux secondaires. L'analyse des valeurs de prix maximum et minimum des barres, conformément aux règles ci-dessus, est assez simple, et ne nécessite aucune explication supplémentaire (voir le texte source dans le fichierGannMicroTrend.mq5).

Pour tracer les sections d'une ligne de tendance, nous utilisons la fonction simple suivante :

//---------------------------------------------------------------------
//  Drawing of a section
//---------------------------------------------------------------------
void  CreateCut(datetime _dt1, double _prc1, datetime _dt2, double _prc2, color _clr, int _wd)
{
  string  name = GetUniqName(prefix + " ");
  CChartObjectTrend*  trend_obj = new CChartObjectTrend();
  if(CheckPointer(trend_obj) != POINTER_INVALID)
  {
    trend_obj.Create(0, name, 0, _dt1, _prc1, _dt2, _prc2);
    trend_obj.Color(_clr);
    trend_obj.Width(_wd);
    trend_list_Ptr.Add(trend_obj);
  }
}

Ici, nous utilisons la fonction pour obtenir un nom unique, dans le graphique, GetUniqName, décrit en détail dans l'article Créer votre propre Veille de Marché à l’aide des Classes de Bibliothèque Standard. En cas de construction réussie de l'objet graphique ligne de tendance, ses paramètres sont spécifiés (couleur et largeur de ligne), et cet objet est ajouté à la liste des lignes en appelant la CList : : Méthode Add

Pour tracer la position des pics/creux secondaires, nous utilisons respectivement les fonctionsCreateUpStopLoss/CreateDnStopLoss Ils sont similaires à la fonctionCreateCut et ajoutent les objets créés à leurs listes.

Une fois le calcul terminé, les paramètres des derniers creux et pics sont affichés. Ici, nous utilisons les listes, créées à l'étape précédente. Nous obtenons ces listes déjà triées par temps en fonction de leur augmentation, et en appelant la CList : : Méthode GetLastNode, nous obtenons le dernier objet pour un pic ou un creux.

Le résultat du travail de l'indicateur décrit est présenté dans la figure suivante:

Figure 2. L'indicateur d'une tendance mineure

2.1. La tendance moyenne

Le graphique de la tendance médiane reflète le mouvement du marché, délimité par deux barres (mouvements à deux barres). Le graphique de la tendance médiane est illustré en figure 2. Examinons brièvement les règles de construction du graphe des tendances moyennes :

• lors d'un mouvement ascendant (lorsque le maximum de la barre suivante est supérieur au maximum du mouvement de deux barres précédent, et que le minimum de la barre suivante est également supérieur au minimum du mouvement de deux barres précédent), nous combinons le prochain maximum de la barre avec le maximum précédent du mouvement à deux barres, et obtenons une ligne d'un mouvement haussier de la tendance intermédiaire ;
• lors d'un mouvement descendant (lorsque le minimum de la barre suivante est inférieur au minimum du mouvement de deux barres précédent, et que le maximum de la barre suivante est également inférieur au minimum du mouvement de deux barres précédent), nous combinons le prochain minimum de la barre avec le minimum précédent du mouvement à deux barres, et obtenons une ligne d'un mouvement à la baisse de la tendance intermédiaire ;
• si lors d'un mouvement ascendant, le maximum de la barre suivante ne dépasse pas le maximum du mouvement de deux barres précédent et, en même temps, le minimum de la barre suivante est inférieur au minimum du mouvement de deux barres précédent, puis la direction du mouvement est passée vers le bas ;
• si lors d'un mouvement ascendant, le maximum de la barre suivante ne dépasse pas le maximum du mouvement de deux barres précédent et, en même temps, le minimum de la barre suivante est inférieur au minimum du mouvement de deux barres précédent, puis la direction du mouvement est passée vers le bas ;
• Si au cours d'un mouvement, le minimum de la barre suivante est supérieur au minimum du mouvement de deux barres précédent et, en même temps, le maximum de la barre suivante est inférieur au maximum du mouvement de deux barres précédent, alors cette barre est appelée inside (voir figure 2) et elle ne participe pas à la construction du graphe ;
• Si lors d'un mouvement, le maximum de la barre suivante est supérieur au maximum de la barre précédente, et en même temps, le minimum de la barre suivante est inférieur au minimum de la barre précédente, alors cette barre est appeléeoutside ( voir la figure 2). En fonction du sens de la barre (vers le haut ou vers le bas), on construit le segment correspondant du graphe.

Figure 3. La tendance modérée

Le seul indicateur de l'inversion de la tendance modéré à la hausse - est l'intersection du niveau du pic modéré. De même, le seul indicateur du renversement vers le bas - est le croisement du niveau inférieur moyen.

Si la tendance modérée est à la hausse et que le marché effectue une fluctuation médiane à la baisse, mais n'annule pas le bas précédent de la fluctuation médiane, il s'agit d'une correction. Et si la tendance modérée est à la baisse et que le marché effectue la fluctuation médiane vers le haut, mais n'annule pas le pic précédent de la fluctuation médiane, il s'agit également d'une correction.

2.2. L'indicateur GannMiddleTrend

Élaborons un indicateur qui montrera le graphique de la tendance médiane. L'apparence doit être la même que dans la figure 2. De plus, les positions des derniers pics et creux doivent être affichées à l'écran. Cet indicateur peut se trouver dans le fichier annexé à cet article,GannMiddleTrend.mq5.

Dans cet indicateur, pour le rendu des éléments du graphe, nous utiliserons l'indicateur buffer et le type de traçage DRAW_COLOR_SECTION Nous en aurons besoin plus tard dans l’élaboration de l' EA. Pour accéder aux données de cet indicateur à partir de l'EA, nous utilisons l'indicateur tampon.

Les paramètres d'affichage de l'indicateur à l'écran sont indiqués par les instructions suivantes :

#property indicator_buffers    2
#property indicator_plots      1
#property indicator_type1      DRAW_COLOR_SECTION
#property indicator_color1     LightGreen, LightPink
#property indicator_width1     4

Ici, nous indiquons de façon successive :

• le nombre de tampons indicateurs (il n'y en a que deux - le tampon de données et le tampon de l'indice de couleur);
• le nombre de graphiques affichés à l'écran ;
• le type de rendu du graphique indicateur (nous allons rendre en utilisant des sections colorées) ;
• les couleurs qui peuvent être indiquées dans le tampon de l'index des couleurs ;
• la largeur de ligne du graphique indicateur ;

Dans la fonction d'initialisation OnInit , nous lions les tampons attribués aux indicateurs et indiquons d'autres paramètres d'indicateur.

Ceci est fait par le fragment de code suivant :

SetIndexBuffer(0, DataBuffer, INDICATOR_DATA);
SetIndexBuffer(1, ColorBuffer, INDICATOR_COLOR_INDEX);

IndicatorSetInteger(INDICATOR_DIGITS, Digits( ));
IndicatorSetString(INDICATOR_SHORTNAME, "GannMiddleTrend");
PlotIndexSetString(0, PLOT_LABEL, "GannMiddleTrend");
PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0);

Ici, nous indiquons de façon successive :

• un tampon à utiliser dans l'indicateur comme tampon de données (pour le rendu sur l'écran) ;
• un tampon pour indiquer la couleur des sections du graphique indicateur ;
• le nombre de points décimaux lors de l'affichage des valeurs de l'indicateur sur l'écran ;
• le nom court de l'indicateur lors de son affichage à l'écran ;
• le nom de la série graphique (tampon de données) lorsqu'il est affiché à l'écran ;
• la valeur, correspondant à la valeur nulle à l'écran (sans rendu) ;

L'indicateur est similaire en structure et en paramètres externes à l'indicateur de la micro tendance GannMicroTrend. La différence est qu'il utilise une attribution directe de valeurs ​dans le tampon de l’indicateur et le tampon de couleurs, au lieu d'utiliser des objets graphiques. Par conséquent, nous ne nous attarderons pas sur les détails de l’implémentation

Le résultat du travail de l'indicateur est illustré dans la figure suivante :

Figure 4, L'indicateur de tendance intermédiaire

Comme on peut le voir, il coïncide avec celui tracé à la main sur la figure 3.

3.1. La Tendance Principale

Le graphique de la tendance principale reflète le mouvement du marché, délimité par trois barres (mouvements à trois barres). L'apparence du graphique de la tendance principale est illustrée en Figure 5. Examinons brièvement les règles de construction de la tendance principale :

• lors d'un mouvement ascendant (lorsque le maximum de la barre suivante est supérieur au maximum du mouvement de trois barres précédent, et que le minimum de la barre suivante est également supérieur au minimum du mouvement de trois barres précédent), nous combinons les prochain maximum de la barre avec le maximum précédent du mouvement à trois barres, et obtenons une ligne du mouvement haussier de la tendance principale ;
• lors d'un mouvement descendant (lorsque le minimum de la barre suivante est inférieur au minimum du mouvement de trois barres précédent, et que le maximum de la barre suivante est également inférieur au minimum du mouvement de trois barres précédent), nous combinons les minimum de la barre suivante avec le minimum précédent du mouvement à trois barres, et obtenons une ligne d'un mouvement à la baisse de la tendance principale ;
• si lors d'un mouvement ascendant, le maximum de la barre suivante ne dépasse pas le maximum du mouvement de trois barres précédent, et en même temps, le minimum de la barre suivante est inférieur au minimum du mouvement de trois barres précédent, puis la direction a changé vers le bas;
• si lors d'un mouvement ascendant, le maximum de la barre suivante ne dépasse pas le maximum du mouvement de trois barres précédent, et en même temps, le minimum de la barre suivante est inférieur au minimum du mouvement de trois barres précédent, puis la direction a changé vers le bas;
• Si pour un mouvement, le minimum de la barre suivante est plus grand que le mouvement de trois barres précédent, et en même temps, le maximum de la barre suivante est inférieur au maximum du mouvement de trois barres précédent, alors cette barre est appelée inside (voir figure 5), et elle ne participe pas à la construction du graphe ;
• Si lors d'un mouvement, le maximum de la barre suivante est supérieur au maximum de la barre précédente, et en même temps, le minimum de la barre suivante est inférieur au minimum de la barre précédente, alors cette barre est appeléeoutside ( voir figure 5). En fonction du sens de la barre (vers le haut ou vers le bas), nous construisons le segment correspondant du graphe.

Figure 5. La tendance principale

Le seul indicateur du renversement de la tendance principale à la hausse - est le croisement du niveau du pic principal. De même, le seul indicateur du renversement vers le bas - est le croisement du niveau du creux principal.

Si la tendance principale est à la hausse et que le marché effectue une fluctuation de baisse, mais n'annule pas la fluctuation du creux précédent, il s'agit d'une correction. Et si la tendance principale est à la baisse et que le marché forme une fluctuation haussière, mais n'annule pas la fluctuation du pic précédent, il s'agit également d'une correction.

3.2. L'indicateur de tendance GannMain

Élaborons un indicateur qui affichera le graphique de la tendance principale. L'apparence doit être la même que dans la figure 5. De plus, les positions des derniers pics et creux doivent être affichées à l'écran. Cet indicateur se trouve dans le fichier, annexé à cet article,GannMainTrend.mq5.

L'indicateur est identique par sa structure et ses paramètres externes à l'indicateur de tendance modéréeGannMiddleTrend, par conséquent, nous ne nous attarderons pas sur les détails de l’implémentation. Le résultat du travail de l'indicateur est illustré dans la figure suivante :

Figure 6. L'indicateur de la tendance principale

4. Trading en utilisant le graphique Fluctuations

Nous avons donc un instrument pour analyser le marché en termes de Modèle - les indicateurs des tendances micro, modérées et principales. Essayons maintenant d’élaborer un système de trading simple, axé sur les fluctuations des prix.

Dans le livre de James Hyerczyk, il suggère la stratégie suivante :

• Identifier les sections avec des mouvements à long terme vers le bas (vers le haut) ;
• Après la formation d'un marché stagnant, se déplaçant dans le sens horizontal, placez une commande d'achat au-dessus du pic (pour vendre sous le bas) de la dernière fluctuation ;
• L’arrêt de sécurité est placée juste en dessous du bas (juste au-dessus du pic) de la dernière fluctuation ;
• Après l'ouverture de la position, le stop est déplacé après le prix, sous les creux générés (pics) des nouvelles fluctuations ;

Illustrons cela par un tracé:

Figure 7. Trading Fluctuant

À des niveaux de prix extrêmement élevés, il est recommandé d'envisager la possibilité d'aller court, et aux niveaux de prix extrêmement bas - les possibilités d'aller long. La figure 7 illustre le graphique de la tendance modérée Nous identifierons les sections avec des mouvements à long terme par le graphique de la tendance principale. Nous identifierons les sections du marché « stagnant » par le graphique de la tendance modérée. La position sera surveillée par le graphique de tendance du modérée

Voici à quoi ressemble la même section sur le graphique de la tendance principale :

Figure 8. La section sur le graphique de la tendance principale

Un mouvement à la baisse à long terme (fluctuation) se situe entre le pic principal 1,36913 et le creux principal 1,18758. Ce mouvement prend 1815,5 points à quatre chiffres. Vient ensuite la section du marché « stagnant », avec une tendance presque horizontale de 1,24664 à 1,21495 (voir figure 7). Ce mouvement prend 316,9 points. Après cela, le prix dépasse le niveau du pic intermédiaire de la dernière fluctuation sur le graphique de tendance intermédiaire et augmente.

Nous fixons le stop initial juste en dessous du bas intermédiaire et de la dernière fluctuation 1,21495, et surveillons la position sur le graphique de la tendance intermédiaire. À la suite de ce trade, nous obtiendrons un bénéfice d'environ 1,31186 - 1,23966 = 722,0 points.

5. Classe de signaux de trading à utiliser dans l'assistant MQL5

Avant de concevoir le code pour l’implémentation de notre système de trading, imaginons schématiquement l'ensemble du déroulement du trade Examinez l'illustration suivante :

Figure 9. Trade aux positions longues

L'ajustement de la position BUY consiste en ce qui suit :

• Définissez, par le graphique de la tendance principale, un mouvement à la baisse à long terme (section AB de la Figure 9). La durée et l'ampleur du mouvement sont indiquées par les paramètresdT and dP , respectivement. Les valeurs ​​de ces paramètres doivent être déterminées sur la base de l'étude de l'historique de cet instrument.
• Après la formation du creux principal sur le graphique de la tendance principale (point B en Figure 9), attendez la formation des points C et D sur le graphique de la tendance intermédiaire. Ces points, avec le point B, forment les fluctuations intermédiaires BC et CD. Si la durée et l'ampleur de ces fluctuations ne dépassent pas les valeurs indiquées, nous admettons alors qu'elles ont formé une tendance horizontale (ou un marché « stagnant »).
• Attendre l'atteinte du niveau du pic intermédiaire C (ou du pic intermédiaire le plus récent, qui se forme après C). Après la brèche, placez l’arrêt juste en dessous du creux intermédiaire au point D (ou le plus récent creux intermédiaire , qui se forme après C).
• Surveillez la position au fur et à mesure du mouvement ascendant, en déplaçant l’arrêt sous le creux intermédiaire formé (juste en dessous des points F et L).
• Selon le mode de gestion du capital, nous pouvons ajouter au volume de position, aux points de rupture, des pics intermédiaires formés (points G et M).

Le réglage de la position SELL consiste en une action d'images miroir.

Ainsi, pour construire un Expert Advisor, nous avons besoin des composants suivants : un module pour générer des signaux d'achat/vente ; un module du trailing stop de la position ouverte, et éventuellement un module, responsable de la position « pyramidale » (money-management).

Lors de la rédaction de cette partie, les articles suivants ont été utilisés : Assistant MQL5 : Comment Créer un Module de Signaux de Trading,, Assistant MQL5 : Comment Créer un Module de Suivi des Positions ouvertes, , assistant MQL5 : Comment Créer un Module de Gestion des Risques et de l'Argent.

L’élaboration du module, chargé de générer des signaux de trading, consiste en ce qui suit :

• Ajoutez une instruction de préprocesseur pour inclure le fichier mqh standard, qui comporte toutes les classes de base pour la génération d'un Expert Advisor. Cela se fait de la manière suivante :

#include <Expert\ExpertSignal.mqh>

Insérez cette instruction au début de notre module de génération d'un signal de trading.

• L'ajout de chaînes spéciales, sous forme de commentaires, qui indiquent à l'éditeurMetaEditor que ce fichier doit être utilisé lors de la génération de l'EA :

// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Signal based on swings on charts                           |
//| of the middle and main trends according to Gann (iCustom)        |
//| Type=Signal                                                      |
//| Name=TGannBreakSignal                                            |
//| Class=TGannBreakSignal                                           |
//| Page=                                                            |
//| Parameter=MinMainSwingContinuance,int,5                          |
//| Parameter=MinMainSwingSize,double,300.0                          |
//| Parameter=MinMiddleSwingContinuance,int,3                        |
//| Parameter=MaxMiddleSwingSize,double,200.0                        |
//| Parameter=OpenPriceSpace,double,5.0                              |
//| Parameter=StopLossSpace,double,5.0                               |
//+------------------------------------------------------------------+
// wizard description end

On voit ici le paramètreTitle , qui précise le nom du module, qui apparaît dans la listeMetaEditor'' lors de la génération de l'EA (voir description ci-dessous). Un paramètre importantType -, qui détermine que le module donné est un module de génération de signal. De plus, les paramètres externes et leurs valeurs par défaut ​sont présents.

Toutes ces lignes sont ajoutées immédiatement après l’instruction d'inclusion du fichier standard ExpertSignal.mqh

• La description de la classe, du descendant de la classe de base, décrite dans le fichierExpertSignal.mqh. Cette classe doit implémenter certaines fonctionnalités, qui manquent dans la classe de base CExpertSignal La description de notre classe dont la vue est la suivante (certaines parties non essentielles ne sont pas montrées ici):

class TGannBreakSignal : public CExpertSignal
  {
private:
   int               min_main_swing_continuance;    // minimum swing duration time of the main tren
   double            min_main_swing_size_points;    // minimum swing amplitude on the chart of the main trend
   int               min_middle_swing_continuance;  // minimum swing duration time on the chart of the middle trend
   double            max_middle_swing_size_points;  // maximum swing amplitude of the chart of the middle trend
   double            open_price_space;              // distance between the open price and peak/bottom
   double            stop_loss_space;               // distance between the stop loss price and peak/bottom

   datetime          main_swing_lf_datetime;        // time of left point of a swing on the chart of the main trend
   double            main_swing_lf_price;           // price of left point of a swing on the chart of the main trend
   datetime          main_swing_rt_datetime;        // time of right point of a swing on the chart of the main trend
   double            main_swing_rt_price;           // price of right point of a swing on the chart of the main trend
   int               main_swing_continuance;        // swing duration time on the chart of the main trend
   double            main_swing_size_points;        // swing amplitude (in points) on the chart of the main trend

   datetime          middle_swing_lf_datetime;      // time of left point of a swing on the chart of the middle trend
   double            middle_swing_lf_price;         // price of left point of a swing on the chart of the middle trend
   datetime          middle_swing_rt_datetime;      // time of right point of a swing on the chart of the middle trend
   double            middle_swing_rt_price;         // price of right point of a swing on the chart of the middle trend
   int               middle_swing_continuance;      // swing duration time on the chart of the middle trend
   double            middle_swing_size_points;      // swing amplitude (in points) on the chart of the middle trend

   int               handle_main_swing;
   int               handle_middle_swing;
   double            main_swing_buff[];
   double            middle_swing_buff[];
   datetime          time_buff[];
   double            price_buff[];
public:
                     TGannBreakSignal();   // constuctor
                    ~TGannBreakSignal();   // destructor
   //   Settings:
   void              MinMainSwingContinuance(int _cont);
   void              MinMainSwingSize(double _size);
   void              MinMiddleSwingContinuance(int _cont);
   void              MaxMiddleSwingSize(double _size);
   void              OpenPriceSpace(double _space);
   void              StopLossSpace(double _space);

   int               GetMainSwingContinuance();    // gets swing duration time on the chart of the main trend
   double            GetMainSwingSizePoints();     // gets swing amplitude (in 4-digit points) on the chart of the main trend
   int               GetMiddleSwingContinuance();  // gets swing duration time on the chart of the middle trend
   double            GetMiddleSwingSizePoints();   // gets swing amplitude (in 4-digit points) on the chart of the middle trend
   
   // overloaded methods of the CExpertSignal class:
   virtual bool      ValidationSettings();
   virtual bool      CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      InitIndicators(CIndicators *indicators);

   //   Additional methods:
protected:
   //   Sets swing parameters of the main trend
   void              SetMainSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price);
   //   Sets swing parameters of the middle trend
   void              SetMiddleSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price);
   // Gets swing parameters of the main trend
   int               GetMainSwing();                  
   // Gets swing parameters of the middle trend
   int               GetMiddleSwing( );                
  };

Le but des données-membres s’affiche clairement d’après les commentaires. Examinez certaines des méthodes de la classe.

Tout d'abord, nous devons redéfinir les méthodes de la classe de base. La première méthode est utilisée pour vérifier l'exactitude des paramètres externes indiqués de l' EA :

//---------------------------------------------------------------------
// Validation of settings
//---------------------------------------------------------------------
bool TGannBreakSignal::ValidationSettings()
  {
   if(this.min_main_swing_continuance<=0)
     {
      Print("Wrong Parameter: min_main_swing_continuance = ",
           this.min_main_swing_continuance);
      return(false);
     }
   if(this.min_main_swing_size_points<=0.0)
     {
      Print("Wrong Parameter: min_main_swing_size_points = ",
            DoubleToString(this.min_main_swing_size_points,1));
      return(false);
     }
   if(this.min_middle_swing_continuance<=0)
     {
      Print("Wrong Parameter: min_middle_swing_continuance = ",
             this.min_middle_swing_continuance);
      return(false);
     }
   if(this.max_middle_swing_size_points<=0.0)
     {
      Print("Wrong Parameter: max_middle_swing_size_points = ",
             DoubleToString(this.max_middle_swing_size_points,1));
      return(false);
     }

   return(true);
  }

Ici, nous effectuons une simple vérification de l'exactitude des paramètres externes. Il est clair que l'ampleur de la fluctuation (en points) et sa durée en mesures ne peuvent être inférieures ou égales à zéro. En cas de paramètres externes incorrectement indiqués, la méthode renvoiefalse

Examinons ensuite les méthodes de génération de signaux pour l'ouverture de positions.

La vérification de la nécessité d'ouvrir une position longue est effectuée par la méthode suivante, héritée de la classe de base :

//---------------------------------------------------------------------
// Checks conditions to open long position
//---------------------------------------------------------------------
bool TGannBreakSignal::CheckOpenLong(double &_price,double &_sl,
                                         double &_tp,datetime &_expiration)
  {
   if(this.GetMainSwing()==-1)
     {
      return(false);
     }

   if(this.GetMiddleSwing()==-1)
     {
      return(false);
     }

// If the main swing upward, exit
   if(this.main_swing_rt_price>=this.main_swing_lf_price)
     {
      return(false);
     }

// If the middle weak swing isn't formed, exit:
   if(this.middle_swing_rt_price>=this.middle_swing_lf_price)
     {
      return(false);
     }

// Check swing parameters on the main trend chart
   if(this.main_swing_continuance<this.min_main_swing_continuance ||
     this.main_swing_size_points<this.min_main_swing_size_points)
     {
      return(false);
     }

// Check swing parameters on the middle trend chart
   if(this.middle_swing_continuance<this.min_middle_swing_continuance ||
      this.middle_swing_size_points>this.max_middle_swing_size_points)
     {
      return(false);
     }

   double unit=this.PriceLevelUnit();

// If the price has crossed the peak of the weak middle swing, set signal to open long position:
   double delta=this.m_symbol.Bid()
             -(this.middle_swing_lf_price+this.open_price_space*unit);
   if((delta>=0.0) && (delta<(10.0*unit)))
     {
      _price=0.0;
      _sl = this.m_symbol.NormalizePrice(this.middle_swing_rt_price - stop_loss_space*unit);
      _tp = 0.0;

      return(true);
     }

   return(false);
  }

Tout d'abord, deux méthodes pour obtenir les paramètres des dernières fluctuations sont appelées, pour les graphiques des tendances principales et intermédiaires -TGannBreakSignal::GetMainSwing et TGannBreakSignal::GetMiddleSwing. Si ces méthodes ont réussi, alors nous pouvons analyser les paramètres des fluctuations.

Puisque nous vérifions la présence du signal d'ouverture d'une position longue, les fluctuations devraient être à la baisse. Nous comparons les positions des points A et B (voir Fig.9) - si le point B a un prix inférieur au point A, alors les fluctuations de prix étaient à la baisse.

Ensuite, nous vérifions la présence des points C et D (voir Figure 9). De plus, le point D doit avoir un prix inférieur à celui du point C. Si cette condition est remplie, alors nous vérifions les paramètres des fluctuations des tendances principales et intermédiaires. La durée et l'ampleur du mouvement sont vérifiées.

Si toutes les vérifications précédentes ont réussi, la dernière vérification est effectuée - que le prix ait ou non franchi le pic de fluctuation intermédiaire. Si c'est le cas, remplissez la valeur d'arrêt et renvoyez le résultat true.

La vérification de la nécessité d'ouvrir une position courte se fait en appelant la méthode TGannBreakSignal :: CheckOpenShort, qui effectue les vérifications similaires à la méthode TGannBreakSignal :: CheckOpenLong, mais dans une image miroir dans l'axe des prix.

Ainsi, nous avons passé en revue la structure et les méthodes de base du module, en charge de la génération des signaux de trading. Le module décrit est joint à cet article dans le fichier GannTrendSignal.mqh.

Le deuxième module dont nous aurons besoin - est le module du stop suiveur d'une position ouverte. Ce module est également élaboré sur la base des classes standard, et se compose des éléments suivants :

• L'ajout de l’instruction de préprocesseur pour inclure le fichier mqh standard, qui comporte les classes de base pour générer le code chargé suivi de position.
  

Cela se fait de la manière suivante :

#include <Expert\ExpertTrailing.mqh>

Insérez cette instruction au début du module de la position entrouverte.

• L'ajout de chaînes spéciales, sous forme de commentaires, indique à l'éditeur MetaEditor que ce fichier doit être utilisé pour générer une position entrouverte dans l' EA :

// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Trailing on peaks/bottoms on the chart of the middle trend |
//| Type=Trailing                                                    |
//| Name=MiddleTrend                                                 |
//| Class=MiddleTrendTrailing                                        |
//| Page=                                                            |
//| Parameter=StopLossSpace,double,5.0                               |
//+------------------------------------------------------------------+
// wizard description end
//+------------------------------------------------------------------+

Ici, le paramètreType est réglé égal à la valeur "Trailing", - cela indique que ce module doit être utilisé pour supporter la position (Trailing). De plus, les paramètres externes et leurs valeurs par défaut ​sont présents.

Toutes ces lignes sont ajoutées immédiatement après l’instruction d'inclure le fichier standardExpertTrailing.mqh

• La description de la classe, un descendant de la classe de base, décrite dans le fichierExpertTrailing.mqh. Cette classe devrait implémenter certaines fonctionnalités, manquantes dans la classe de base CExpertTrailing.. La description de notre classe dont la vue est la suivante (certaines parties non essentielles ne sont pas montrées ici):

class MiddleTrendTrailing : public CExpertTrailing
  {
private:
   datetime          middle_swing_lf_datetime;  // time of left point of a swing on the chart of the main trend
   double            middle_swing_lf_price;     // price of left point of a swing on the chart of the main trend
   datetime          middle_swing_rt_datetime;  // time of right point of a swing on the chart of the main trend
   double            middle_swing_rt_price;     // price of right point of a swing on the chart of the main trend
   double            stop_loss_space;           // the distance between peak/bottom and stop loss price

   int               handle_middle_swing;
   double            middle_swing_buff[];
   datetime          time_buff[];
   double            price_buff[];
public:
                     MiddleTrendTrailing();     // constructor
                    ~MiddleTrendTrailing();     // destructor
private:
   int               GetMiddleSwing();          // get parameters of the middle swing

public:
   //   Settings:
   void              StopLossSpace(double _space);
   //   Overloaded methods of CExpertTrailing class:
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);
   virtual bool      CheckTrailingStopLong(CPositionInfo *position,double &sl,double &tp);
   virtual bool      CheckTrailingStopShort(CPositionInfo *position,double &sl,double &tp);
  };

Les méthodes de base, redéfinies dans notre classe - MiddleTrendTrailing :: CheckTrailingStopLong et MiddleTrendTrailing : : CheckTrailingStopShort. Ces deux méthodes vérifient les conditions de modification du stop-loss pour respectivement une position longue et courte.

Examinez la méthode MiddleTrendTrailing : : CheckTrailingStopLong plus en détail :

//---------------------------------------------------------------------
// Checks conditions of trailing stop for long position
//---------------------------------------------------------------------
bool MiddleTrendTrailing::CheckTrailingStopLong(CPositionInfo *_position,double &_sl,double &_tp)
  {
   if(_position==NULL)
     {
      return(false);
     }

   if(this.GetMiddleSwing()==-1)
     {
      return(false);
     }

   double sl_req_price = this.m_symbol.NormalizePrice(MathMin(middle_swing_lf_price,middle_swing_rt_price)
                      - this.stop_loss_space * this.m_adjusted_point );
   if(_position.StopLoss() >= sl_req_price )
     {
      return(false);
     }

   _tp = EMPTY_VALUE;
   _sl = sl_req_price;

   return(true);
  }

Nous appelons d'abord la méthode pour obtenir les paramètres de la dernière fluctuation pour le graphique de tendance du milieu - TGannBreakSignal :: GetMiddleSwing. Si cette méthode réussit (a renvoyé une valeur nulle), il est possible d'analyser les paramètres des fluctuations.

Ensuite, nous calculons le niveau de prix pour placer le stop-loss, sur la base des paramètres de fluctuation obtenus. Si le niveau calculé du stop-loss est inférieur au niveau actuel (pour la position longue), alors nous remplissons le paramètre de la méthode __sl new value sl_req_price et renvoie true. Sinon, renvoyezfalse - cela suggère que le niveau du stop-loss ne nécessite pas de modification.

La méthode de vérification de la nécessité de modifier le stop-loss pour une position courte est construite de manière analogue.

Ainsi, nous avons passé en revue la structure et les méthodes de base du module, chargé du suivi d'une position ouverte (trailing). Le module décrit est joint à cet article dans le fichier GannTrailing.mqh.

La génération de l' EA sur la base des signaux de trading

La génération de l' EA par un modèle, à l'aide du "Masters MQL5", est une tâche assez simple. Il se compose d'une séquence d'étapes :

• Étape 1.

A l'aide des commandes du menu principal MetaEditor'a File / New, appelez le maître de la génération EA. L'écran affiche une fenêtre de la boîte de dialogue de la vue suivante :

Figure 10. Création d'une boîte de dialogue Expert Advisor prête dans l'assistant MQL5

Sélectionnez le "bouton radio" avec l'inscription "EA (générer)" et cliquez sur le bouton "Suivant" - passez à l'étape suivante de génération de l 'EA.

• Étape 2.

Dans cette étape, nous indiquons les paramètres généraux de l' EA - le nom, le nombre "magique", etc. La fenêtre de dialogue suivante apparaît :

Figure 11. Propriétés générales de l'Expert Advisor

Indiquez la valeur du paramètre EveryTick dans true- nous avons besoin du travail de l' EA pour chaque tick, le nombre "magique" peut rester inchangé. Cliquez sur le bouton "Suivant" et passez à l'étape suivante de la génération.

• Étape 3.

Dans cette étape, indiquez les paramètres des signaux pour l' EA. Tout d'abord, nous sélectionnons le type particulier d'un signal dans la liste :

Figure 12. La sélection du module de signaux de trade

Sélectionnez le nom de notre signal, écrit précédemment, et la boîte de dialogue du type suivant apparaît à l'écran :

Figure 13. Paramètres d'entrée du module de signal de trading

Ici, nous pouvons corriger les valeurs par défaut des paramètres qui nous sont nécessaires. Encore une fois, appuyez sur le bouton "Suivant" et passez à l'étape suivante.

• Étape 4.

Dans cette étape, sélectionnez le type de suivi pour prendre en charge la position ouverte. Nous pouvons sélectionner n'importe lequel dans la liste, mais nous sélectionnerons la méthode du trailing-stop précédemment élaboré :

Figure 14. Sélectionnez le type de position entrouverte

Nous obtenons la fenêtre de dialogue suivante :

Figure 15. Indication des paramètres de suivi

Ici, nous pouvons ajuster les valeurs par défaut pour les paramètres externes indiqués. Appuyez sur le bouton "Suivant" et passez à l'étape suivante.

• Étape 5.
  

Figure 16. Indication des paramètres de la gestion de l'argent

Ici, nous pouvons sélectionner les paramètres de gestion du capital (la méthode de calcul du lot de travail). Laissez-le tel quel - Tradez avec un volume de trading fixe. Appuyez sur le bouton "Terminé" pour obtenir un EA généré prêt avec un nom spécifié, un algorithme d'ouverture de position, de suivi et des règles de gestion du capital.

Testez l' EA généré pour vous assurer qu'il est opérationnel :

Figure 17. Testez l'Expert Advisor créé

Nous constatons que les tendances, correctement identifiées, ont été prises complètement (dans la mesure où cette méthode le permet). De plus, nous avons utilisé les paramètres par défaut, indiqués par des considérations générales.

Conclusion

En fait, nous n'avons examiné que la première partie de la théorie de Gann et son application dans les systèmes de trading et l'analyse de marché - le modèle. Il semble que les meilleurs résultats de son application puissent être obtenus dans ces périodes, où la division du graphique en barres correspond à l'organisation naturelle du trade.

Pour les marchés boursiers - il s'agit de trade utilisant des intervalles quotidiens, hebdomadaires et mensuels. Pour le marché des devises - c'est le trade, en utilisant des intervalles de session. Pour les marchés des matières de base - il s'agit de trade utilisant non seulement des intervalles quotidiens, hebdomadaires et mensuels, mais également des fluctuations saisonnières sur le marché.

Après la conclusion

J'ai décidé de faire une petite recherche supplémentaire, pas directement liée au sujet, mais concernant l'idée de ​​Gann. Plus précisément, la question : Le cours, lors de son mouvement, marque-t-il les niveaux dits « ronds » ? C'est-à-dire les niveaux de prix, se terminant par les chiffres 50 et 100 pour les euro-devises et les actions (pour le yen japonais, un niveau de prix « rond » est un se terminant par 40).

Pour cela, construisons un diagramme de répartition des pics/creux sur les derniers chiffres après la virgule. Pour les cotations à cinq chiffres, il y a les trois derniers chiffres après la virgule (le dernier chiffre - les dixièmes de point). Nous utiliserons le graphique de tendance intermédiaire pour les barres quotidiennes.

Sur un axe circulaire, nous traçons les derniers chiffres du prix, de zéro à cinquante (arrondir au dixième de point), tandis que sur l'axe vertical - le nombre de pics/creux formés à ces niveaux. Construisez-le séparément pour les pics, les creux et le chiffre total.

Voici ce que nous avons pour certaines des principales paires de devises dans l'intervalle de l'année 2000 à 2011. et un calendrier quotidien :

Comment interpréter ces résultats ? Tout d'abord, il y a des distorsions dans les diagrammes. C'est-à-dire pas toutes les valeurs de prix ​sont également susceptibles de former des pics/creux. Deuxièmement, ces valeurs ​ne coïncident pas exactement avec les valeurs "arrondies" ​- c'est ce qui était fondamentalement attendu. Il est difficile de dire si cela peut être utilisé pour le trade Cela nécessite une recherche plus sérieuse. Des résultats peut-être plus intéressants, d'un point de vue pratique, peuvent être obtenus en bourse.

Du moins, c'est un autre instrument d'analyse de l'histoire et pas le pire du genre.