Aller au contenu

Comment tracer la fourche d'Andrews

La fourche d'Andrews est un outil d'analyse technique populaire utilisé, parfois avec d'autres indicateurs, pour identifier les niveaux potentiels de support et de résistance dans un marché en tendance. Ces niveaux constituent une base essentielle pour des stratégies de trading réussies, offrant aux traders clarté, structure et confiance dans leurs décisions.

Cet article et sa vidéo correspondante démontreront comment créer un cBot qui trace la fourche d'Andrews sur un graphique, et coder la fourche pour qu'elle se mette à jour automatiquement lorsque le graphique change.

Tracer la fourche d'Andrews sur un graphique

La fourche d'Andrews se compose d'une ligne médiane (ligne centrale) et de deux lignes parallèles qui forment un canal. Ces objets aident les traders à visualiser les tendances, à prévoir les mouvements de prix et à identifier les points d'entrée et de sortie potentiels pour les trades.

La fourche d'Andrews est tracée sur un graphique de prix en utilisant trois points clés : un haut, un bas et un point haut ou bas ultérieur. Le mouvement des prix dans ce canal oscille souvent entre les lignes supérieure et inférieure, tandis que la ligne médiane sert de point de retour.

Nous allons créer un cBot qui trace une fourche d'Andrews en tendance haussière, ce qui nécessite généralement deux bas et un haut entre les deux. L'inverse est le cas pour une fourche d'Andrews en tendance baissière : deux hauts et un bas entre les deux seraient nécessaires.

Dans cTrader Algo, cliquez sur le bouton Nouveau pour créer un cBot et saisissez un nom pour celui-ci, puis cliquez sur Créer.

La fourche d'Andrews nécessite six paramètres pour stocker les éléments suivants : indices du haut et des deux bas, deux prix minimums et un prix haut. Déclarez les six paramètres.

1
2
3
4
5
6
private int _highIndex;
private int _lowIndex1;
private int _lowIndex2;
private double _max;
private double _min1;
private double _min2;

Détectez les deux prix minimums et le prix élevé nécessaires pour les points de la fourche.

1
2
3
_max = Bars.HighPrices.Maximum(50);
_min1 = Bars.LowPrices.Minimum(50);
_min2 = Bars.LowPrices.Minimum(10);

cTrader Algo vous permet de définir l'emplacement temporel par le biais de méthodes fournissant soit le temps absolu, soit l'indice de barre relatif. La méthode utilisée pour dessiner la fourche sur le graphique introduit les remplacements pertinents. Dans ce cas, nous avons choisi l'indice de barre relatif.

Écrivez le code pour détecter les indices des prix élevés et bas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
for (int i = 0; i <= 50; i++)
{
    if (Bars.HighPrices.Last(i) == _max)
        _highIndex = Bars.Count - i - 1;
}

for (int i = 0; i <= 50; i++)
{
    if (Bars.LowPrices.Last(i) == _min1)
        _lowIndex1 = Bars.Count - i - 1;
}

for (int i = 0; i <= 10; i++)
{
    if (Bars.LowPrices.Last(i) == _min2)
        _lowIndex2 = Bars.Count - i - 1;
}

Dessinez la fourche sur le graphique.

1
Chart.DrawAndrewsPitchfork("AndrewsPitchfork", _lowIndex1, _min1, _highIndex, _max, _lowIndex2, _min2, Color.Red);

Vous pouvez copier le code complet ci-dessous :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class AndrewsPitchfork : Robot
    {
        private int _highIndex;
        private int _lowIndex1;
        private int _lowIndex2;
        private double _max;
        private double _min1;
        private double _min2;

        protected override void OnStart()
        {
            _max = Bars.HighPrices.Maximum(50);
            _min1 = Bars.LowPrices.Minimum(50);
            _min2 = Bars.LowPrices.Minimum(10);

            for (int i = 0; i <= 50; i++)
            {
                if (Bars.HighPrices.Last(i) == _max)
                    _highIndex = Bars.Count - i - 1;
            }

            for (int i = 0; i <= 50; i++)
            {
                if (Bars.LowPrices.Last(i) == _min1)
                    _lowIndex1 = Bars.Count - i - 1;
            }

            for (int i = 0; i <= 10; i++)
            {
                if (Bars.LowPrices.Last(i) == _min2)
                    _lowIndex2 = Bars.Count - i - 1;
            }

            Chart.DrawAndrewsPitchfork("AndrewsPitchfork", _lowIndex1, _min1, _highIndex, _max, _lowIndex2, _min2, Color.Red);

        }

        protected override void OnTick()
        {
            // Handle price updates here
        }

        protected override void OnStop()
        {
            // Handle cBot stop here
        }
    }
}

Pour créer le cBot, utilisez le raccourci clavier Ctrl+B ou cliquez sur Créer.

Ajoutez une instance locale du cBot : cliquez sur Ajouter une instance, sélectionnez l'option Localement, puis cliquez sur Ajouter une instance.

Cliquez sur l'instance et accédez à l'onglet Backtesting. Sélectionnez une période pour le backtesting, activez l'option Mode visuel, puis cliquez sur l'icône de lecture.

Vous devriez voir la fourche d'Andrews dessinée sur le graphique.

Mettre à jour la fourche d'Andrews

Retournez à l'application Algo et codez le cBot pour mettre à jour la fourche au fur et à mesure que le graphique change.

Créez une nouvelle méthode pour dessiner la fourche et déplacez la logique d'origine dans cette méthode.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
private void DrawAndrewsPitchfork()
{
    _max = Bars.HighPrices.Maximum(50);
    _min1 = Bars.LowPrices.Minimum(50);
    _min2 = Bars.LowPrices.Minimum(10);

    for (int i = 0; i <= 50; i++)
    {
        if (Bars.HighPrices.Last(i) == _max)
            _highIndex = Bars.Count - i - 1;
    }

    for (int i = 0; i <= 50; i++)
    {
        if (Bars.LowPrices.Last(i) == _min1)
            _lowIndex1 = Bars.Count - i - 1;
    }

    for (int i = 0; i <= 10; i++)
    {
        if (Bars.LowPrices.Last(i) == _min2)
            _lowIndex2 = Bars.Count - i - 1;
    }

    if (_lowIndex1 < _highIndex && _highIndex < _lowIndex2)
        Chart.DrawAndrewsPitchfork("AndrewsPitchfork", _lowIndex1, _min1, _highIndex, _max, _lowIndex2, _min2, Color.Red);
}

Appelez la nouvelle méthode dans la méthode OnBar().

1
2
3
4
protected override void OnBar()
{
    DrawAndrewsPitchfork();
}

Étant donné que seules les configurations de tendance haussière sont nécessaires, écrivez la logique conditionnelle qui vérifie que les minimums et les maximums sont dans le bon ordre.

1
2
if (_lowIndex1 < _highIndex && _highIndex < _lowIndex2)
    Chart.DrawAndrewsPitchfork("AndrewsPitchfork", _lowIndex1, _min1, _highIndex, _max, _lowIndex2, _min2, Color.Red);

Vous pouvez copier le code complet ci-dessous :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class AndrewsPitchfork : Robot
    {
        private int _highIndex;
        private int _lowIndex1;
        private int _lowIndex2;
        private double _max;
        private double _min1;
        private double _min2;

        protected override void OnStart()
        {

        DrawAndrewsPitchfork(); 

        }

        private void DrawAndrewsPitchfork() 
        {
           _max = Bars.HighPrices.Maximum(50);
            _min1 = Bars.LowPrices.Minimum(50);
            _min2 = Bars.LowPrices.Minimum(10);

            for (int i = 0; i <= 50; i++)
            {
                if (Bars.HighPrices.Last(i) == _max)
                    _highIndex = Bars.Count - i - 1;
            }

            for (int i = 0; i <= 50; i++)
            {
                if (Bars.LowPrices.Last(i) == _min1)
                    _lowIndex1 = Bars.Count - i - 1;
            }

            for (int i = 0; i <= 10; i++)
            {
                if (Bars.LowPrices.Last(i) == _min2)
                    _lowIndex2 = Bars.Count - i - 1;
            }

            if (_lowIndex1 < _highIndex && _highIndex < _lowIndex2)
                 Chart.DrawAndrewsPitchfork("AndrewsPitchfork", _lowIndex1, _min1, _highIndex, _max, _lowIndex2, _min2, Color.Red);
        }

        protected override void OnBar()
        {
            DrawAndrewsPitchfork(); 
        }

        protected override void OnStop()
        {
            // Handle cBot stop here
        }
    }
}

Créez à nouveau le cBot et effectuez un backtesting.

Augmentez la vitesse du mode visuel et cliquez sur l'icône de lecture.

Cette fois, vous devriez voir comment la fourche est constamment redessinée au fur et à mesure que le graphique change.

Résumé

Cet article a expliqué comment dessiner la fourche d'Andrews sur un graphique de symbole et coder la fourche pour qu'elle se mette à jour au fur et à mesure que le graphique change.