Przejdź do treści

Jak narysować widły Andrew'sa

Widły Andrew'sa to popularne narzędzie analizy technicznej używane, czasami wraz z innymi wskaźnikami, do identyfikacji potencjalnych poziomów wsparcia i oporu na rynku w trendzie. Poziomy te stanowią kluczową podstawę skutecznych strategii handlowych, dając traderom jasność, strukturę i pewność w podejmowaniu decyzji.

Ten artykuł i odpowiadające mu wideo pokażą, jak stworzyć cBota, który rysuje widły Andrew'sa na wykresie, i zakodować widły tak, aby automatycznie aktualizowały się wraz ze zmianami wykresu.

Narysuj widły Andrew'sa na wykresie

Widły Andrew'sa składają się z linii środkowej (linii centralnej) i dwóch linii równoległych, które tworzą kanał. Te obiekty pomagają traderom wizualizować trendy, prognozować ruchy cen oraz identyfikować potencjalne punkty wejścia i wyjścia z transakcji.

Widły Andrew'sa są rysowane na wykresie cenowym przy użyciu trzech kluczowych punktów: szczytu, dołka i kolejnego szczytu lub dołka. Ruch ceny w tym kanale często oscyluje między górną i dolną linią, podczas gdy linia środkowa służy jako punkt powrotu.

Stworzymy cBota, który rysuje widły Andrew'sa w trendzie wzrostowym, co zazwyczaj wymaga dwóch dołków i szczytu pomiędzy nimi. Odwrotnie jest w przypadku widłów Andrew'sa w trendzie spadkowym: potrzebne byłyby dwa szczyty i dołek pomiędzy nimi.

W cTrader Algo kliknij przycisk Nowy, aby utworzyć cBota i wprowadź dla niego nazwę, a następnie kliknij Utwórz.

Widły Andrew'sa wymagają sześciu parametrów do przechowywania następujących danych: indeksów szczytu i dwóch dołków, dwóch minimalnych cen i ceny maksymalnej. Zadeklaruj sześć parametrów.

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

Wykryj dwie minimalne ceny i cenę maksymalną potrzebne do punktów widłów.

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

cTrader Algo pozwala zdefiniować lokalizację czasową za pomocą metod dostarczających albo czas bezwzględny, albo względny indeks słupka. Metoda użyta do narysowania widłów na wykresie wprowadza odpowiednie nadpisania. W tym przypadku wybraliśmy względny indeks słupka.

Napisz kod do wykrywania indeksów cen maksymalnych i minimalnych.

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

Narysuj widły na wykresie.

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

Możesz skopiować pełny kod poniżej:

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

Aby zbudować cBota, użyj skrótu klawiszowego Ctrl+B lub kliknij Zbuduj.

Dodaj lokalną instancję cBota: kliknij Dodaj instancję, wybierz opcję Lokalnie, a następnie kliknij Dodaj instancję.

Kliknij wystąpienie i przejdź do zakładki Backtesting. Wybierz okres dla backtestingu, włącz opcję Tryb wizualny, a następnie kliknij ikonę odtwarzania.

Powinieneś zobaczyć widły Andrew'sa narysowane na wykresie.

Aktualizuj widły Andrew'sa

Wróć do aplikacji Algo i zakoduj cBota tak, aby aktualizował widły wraz ze zmianami wykresu.

Utwórz nową metodę do rysowania widłów i przenieś oryginalną logikę do tej metody.

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

Wywołaj nową metodę w metodzie OnBar().

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

Ponieważ potrzebne są tylko ustawienia trendu wzrostowego, napisz logikę warunkową, która weryfikuje, czy minima i maksima są w prawidłowej kolejności.

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

Możesz skopiować pełny kod poniżej:

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

Zbuduj cBota ponownie i przeprowadź backtesting.

Zwiększ prędkość trybu wizualnego i kliknij ikonę odtwarzania.

Tym razem powinieneś zobaczyć, jak widły są stale przerysowywane wraz ze zmianami wykresu.

Podsumowanie

Ten artykuł wyjaśnił, jak narysować widły Andrew'sa na wykresie symbolu i zakodować widły tak, aby aktualizowały się wraz ze zmianami wykresu.