Saltar a contenido

Cómo dibujar el Tenedor de Andrews

El Tenedor de Andrews es una herramienta popular de análisis técnico utilizada, a veces con otros indicadores, para identificar posibles niveles de soporte y resistencia en un mercado con tendencia. Estos niveles sirven como base crítica para estrategias de operación exitosas, dando a los operadores claridad, estructura y confianza en sus decisiones.

Este artículo y su video correspondiente demostrarán cómo crear un cBot que dibuja el Tenedor de Andrews en un gráfico, y codificar el tenedor para que se actualice automáticamente a medida que cambia el gráfico.

Dibujar el Tenedor de Andrews en un gráfico

El Tenedor de Andrews consiste en una línea media (línea central) y dos líneas paralelas que forman un canal. Estos objetos ayudan a los operadores a visualizar tendencias, pronosticar movimientos de precios e identificar posibles puntos de entrada y salida para las operaciones.

El Tenedor de Andrews se dibuja en un gráfico de precios utilizando tres puntos clave: un máximo, un mínimo y un punto máximo o mínimo subsiguiente. El movimiento del precio dentro de este canal a menudo oscila entre las líneas superior e inferior, mientras que la línea media sirve como punto de reversión.

Crearemos un cBot que dibuja un Tenedor de Andrews en tendencia alcista, que típicamente requiere dos mínimos y un máximo entre ellos. Lo contrario es el caso para un Tenedor de Andrews en tendencia bajista: se necesitarían dos máximos y un mínimo entre ellos.

En cTrader Algo, haga clic en el botón Nuevo para crear un cBot e ingrese un nombre para él, luego haga clic en Crear.

El Tenedor de Andrews requiere seis parámetros para almacenar lo siguiente: índices del máximo y dos mínimos, dos precios mínimos y un precio máximo. Declare los 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;

Detecte los dos precios mínimos y el precio máximo necesarios para los puntos del tenedor.

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

cTrader Algo le permite definir la ubicación temporal a través de métodos que proporcionan el tiempo absoluto o el índice de barra relativo. El método utilizado para dibujar el tenedor en el gráfico introduce las anulaciones relevantes. En este caso, elegimos el índice de barra relativo.

Escriba el código para detectar los índices de los precios máximos y mínimos.

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

Dibuje el tenedor de Andrews en el gráfico.

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

Puede copiar el código completo a continuación:

 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 construir el cBot, use el atajo Ctrl+B o haga clic en Construir.

Añada una instancia local del cBot: haga clic en Añadir instancia, seleccione la opción Localmente y luego haga clic en Añadir instancia.

Haga clic en la instancia y navegue a la pestaña Backtesting. Seleccione un período para el backtesting, active la opción Modo visual y luego haga clic en el icono de reproducción.

Debería ver el Tenedor de Andrews dibujado en el gráfico.

Actualizar el Tenedor de Andrews

Vuelva a la aplicación Algo y codifique el cBot para actualizar el tenedor a medida que cambia el gráfico.

Cree un nuevo método para dibujar el tenedor y mueva la lógica original a ese 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);
}

Llame al nuevo método en el método OnBar().

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

Dado que solo se necesitan configuraciones de tendencia alcista, escriba la lógica condicional que verifica que los mínimos y máximos estén en el orden correcto.

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

Puede copiar el código completo a continuación:

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

Construya el cBot de nuevo y haga un backtesting.

Aumente la velocidad del modo visual y haga clic en el icono de reproducción.

Esta vez, debería ver cómo el tenedor se redibuja constantemente a medida que cambia el gráfico.

Resumen

Este artículo ha explicado cómo dibujar el Tenedor de Andrews en un gráfico de símbolo y codificar el tenedor para que se actualice a medida que cambia el gráfico.