Ir para o conteúdo

Como desenhar o Garfo de Andrews

O garfo de Andrews é uma ferramenta de análise técnica popular utilizada, por vezes com outros indicadores, para identificar potenciais níveis de suporte e resistência num mercado com tendência. Estes níveis servem como uma base crítica para estratégias de negociação bem-sucedidas, dando aos traders clareza, estrutura e confiança nas suas decisões.

Este artigo e o vídeo correspondente demonstrarão como criar um cBot que desenha o Garfo de Andrews num gráfico e codificar o garfo para se atualizar automaticamente à medida que o gráfico muda.

Desenhar o Garfo de Andrews num gráfico

O Garfo de Andrews consiste numa linha mediana (linha central) e duas linhas paralelas que formam um canal. Estes objetos ajudam os traders a visualizar tendências, prever movimentos de preços e identificar potenciais pontos de entrada e saída para negociações.

O Garfo de Andrews é desenhado num gráfico de preços utilizando três pontos-chave: um máximo, um mínimo e um ponto subsequente máximo ou mínimo. O movimento do preço dentro deste canal frequentemente oscila entre as linhas superior e inferior, enquanto a linha mediana serve como ponto de reversão.

Vamos criar um cBot que desenha um Garfo de Andrews em tendência ascendente, o que normalmente requer dois mínimos e um máximo entre eles. O inverso é o caso para um Garfo de Andrews em tendência descendente: seriam necessários dois máximos e um mínimo entre eles.

No cTrader Algo, clique no botão Novo para criar um cBot e introduza um nome para ele, depois clique em Criar.

O Garfo de Andrews requer seis parâmetros para armazenar o seguinte: índices do máximo e dos dois mínimos, dois preços mínimos e um preço máximo. Declare os seis parâmetros.

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

Detete os dois preços mínimos e o preço máximo necessários para os pontos do garfo.

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

O cTrader Algo permite-lhe definir a localização temporal através de métodos que fornecem o tempo absoluto ou o índice de barra relativo. O método utilizado para desenhar o garfo no gráfico introduz as substituições relevantes. Neste caso, escolhemos o índice de barra relativo.

Escreva o código para detetar os índices dos preços máximo e mínimo.

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

Desenhe o garfo no gráfico.

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

Pode copiar o código completo abaixo:

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

Para criar o cBot, utilize o atalho Ctrl+B ou clique em Criar.

Adicione uma instância local do cBot: clique em Adicionar instância, selecione a opção Localmente e depois clique em Adicionar instância.

Clique na instância e navegue até ao separador Testes de verificação. Selecione um período para os testes de verificação, ative a opção Modo visual e depois clique no ícone de reprodução.

Deverá ver o Garfo de Andrews desenhado no gráfico.

Atualizar o Garfo de Andrews

Volte à aplicação Algo e programe o cBot para atualizar o garfo à medida que o gráfico muda.

Crie um novo método para desenhar o garfo e mova a lógica original para esse método.

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

Chame o novo método no método OnBar().

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

Uma vez que apenas são necessárias configurações de tendência ascendente, escreva a lógica condicional que verifica se os mínimos e máximos estão na ordem correta.

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

Pode copiar o código completo abaixo:

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

Crie o cBot novamente e teste-o.

Aumente a velocidade do modo visual e clique no ícone de reprodução.

Desta vez, deverá ver como o garfo é constantemente redesenhado à medida que o gráfico muda.

Resumo

Este artigo explicou como desenhar o Garfo de Andrews num gráfico de símbolo e programar o garfo para se atualizar à medida que o gráfico muda.