Vai al contenuto

Come disegnare la forchetta di Andrews

La forchetta di Andrews è un popolare strumento di analisi tecnica utilizzato, a volte insieme ad altri indicatori, per identificare potenziali livelli di supporto e resistenza in un mercato in trend. Questi livelli fungono da fondamento critico per strategie di trading di successo, offrendo ai trader chiarezza, struttura e fiducia nelle loro decisioni.

Questo articolo e il video corrispondente dimostreranno come creare un cBot che disegna la forchetta di Andrews su un grafico e come codificare la forchetta per aggiornarsi automaticamente al variare del grafico.

Disegna la forchetta di Andrews su un grafico

La forchetta di Andrews è composta da una linea mediana (linea centrale) e due linee parallele che formano un canale. Questi oggetti aiutano i trader a visualizzare i trend, prevedere i movimenti dei prezzi e identificare potenziali punti di entrata e uscita per le operazioni.

La forchetta di Andrews viene disegnata su un grafico dei prezzi utilizzando tre punti chiave: un massimo, un minimo e un successivo punto massimo o minimo. Il movimento dei prezzi all'interno di questo canale spesso oscilla tra le linee superiore e inferiore, mentre la linea mediana funge da punto di inversione.

Creeremo un cBot che disegna una forchetta di Andrews in uptrend, che tipicamente richiede due minimi e un massimo nel mezzo. Il contrario è il caso per una forchetta di Andrews in downtrend: sarebbero necessari due massimi e un minimo nel mezzo.

In cTrader Algo, clicca sul pulsante Nuovo per creare un cBot e inserisci un nome, quindi clicca su Crea.

La forchetta di Andrews richiede sei parametri per memorizzare quanto segue: indici del massimo e dei due minimi, due prezzi minimi e un prezzo massimo. Dichiara i sei parametri.

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

Rileva i due prezzi minimi e il prezzo massimo necessari per i punti della forchetta.

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

cTrader Algo ti consente di definire la posizione temporale tramite metodi che forniscono il tempo assoluto o l'indice di barra relativo. Il metodo utilizzato per disegnare la forchetta sul grafico introduce gli override pertinenti. In questo caso, abbiamo scelto l'indice di barra relativo.

Scrivi il codice per rilevare gli indici dei prezzi massimi e minimi.

 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;
}

Disegna la forchetta sul grafico.

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

Puoi copiare il codice completo qui sotto:

 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
        }
    }
}

Per compilare il cBot, usa la scorciatoia Ctrl+B o clicca su Compila.

Aggiungi un'istanza locale del cBot: clicca su Aggiungi istanza, seleziona l'opzione Localmente, quindi clicca su Aggiungi istanza.

Clicca sull'istanza e vai alla scheda Backtesting. Seleziona un periodo per il backtesting, abilita l'opzione Modalità visiva e quindi clicca sull'icona play.

Dovresti vedere la forchetta di Andrews disegnata sul grafico.

Aggiorna la forchetta di Andrews

Torna all'app Algo e codifica il cBot per aggiornare la forchetta al variare del grafico.

Crea un nuovo metodo per disegnare la forchetta e sposta la logica originale in quel metodo.

 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);
}

Chiama il nuovo metodo nel metodo OnBar().

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

Poiché sono necessari solo setup in uptrend, scrivi la logica condizionale che verifica che i minimi e i massimi siano nell'ordine corretto.

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

Puoi copiare il codice completo qui sotto:

 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
        }
    }
}

Compila nuovamente il cBot ed esegui il backtesting.

Aumenta la velocità della modalità visiva e clicca sull'icona play.

Questa volta, dovresti vedere come la forchetta viene costantemente ridisegnata al variare del grafico.

Questo articolo ha spiegato come disegnare la forchetta di Andrews su un grafico di simboli e come codificare la forchetta per aggiornarsi automaticamente al variare del grafico.