15/04/2021

Как писать алгоритмы для ATAS. Инструкция для новичков

Как писать алгоритмы для ATAS пошаговая инструкция

В платформе ATAS, помимо всех ее полезных индикаторов и кластерных графиков, есть крутейшая возможность подключения собственных алгоритмов по API. Она открывает путь к безграничным вариантам использования мощностей ATAS:

проверке своих торговых идей на гигабайтах тиковой истории по акциям, фьючерсам, криптовалютам;
созданию собственных индикаторов,
созданию авторских полностью автоматических стратегий с прямым подключением к главным биржам.

Естественно, для этого нужно уметь программировать. А именно – на С# (си шарп), так как ATAS написан на этом распространенном языке от Microsoft. В Базе знаний есть целый раздел, посвященный использованию API. Но он больше ориентирован на тех, кто имеет опыт в программировании и знаком с терминологией.

Данная же обучающая статья создана непрофессиональным программистом, здесь все описывается простыми словами. Статья – практическая, она предназначена для новичков в С#, тем не менее вам необходим хотя бы небольшой опыт в трейдинге с использованием платформы ATAS.

Цели статьи:

Показать, как взаимодействуют торгово-аналитическая платформа ATAS и среда разработки Visual Studio, в которой создаются программы на языке C#.
Дать поверхностные вводные знания в язык С#. По тексту есть недосказанности, это естественно, так как вы можете нагуглить недостающую справочную информацию о С# из открытых источников. Иначе статья превратится в талмуд на 1000 страниц.

Если вы захотите развиваться в создании своих алгоритмов для подключения их по API к ATAS, то безусловно вам обязательно надо будет изучать С# по книгам, курсам, видеороликам, коих в интернете предостаточно. Там доступно объясняются методы, классы, типы переменных, операции с ними, массивы, циклы и так далее – все что надо для создания кода. Но вряд ли там будут примеры индикаторов, работающих с реальными биржевыми данными. Зато их вы найдете ниже.

Читайте в статье:

Установка Visual Studio;
Перенос алгоритмов из Visual Studio в ATAS;
Написание простейших алгоритмов;
Проверка эффективности торговли по простейшей стратегии;
Бонус.

В конце статьи вы получите файл для Visual Studio с исходным кодом, который используется в тексте. Если будут вопросы – задавайте в комментариях.

Поехали!

Начни пользоваться ATAS совершенно бесплатно и без ограничений по времени! Или сразу подключай продвинутый тариф и получи доступ к полному функционалу.

Попробовать ATAS бесплатно

С чего начать

Начать следует с того, чтобы установить Microsoft Visual Studio – это среда, в которой на языке C# разрабатываются разные продукты, в том числе – библиотеки dll. Именно в формате библиотек dll к ATAS можно подключить свои алгоритмы.

Скачать дистрибутив программы Visual Studio Community (бесплатная версия, ее будет достаточно) можно по адресу visualstudio.microsoft.com//downloads/

Устанавливаем Visual Studio на свой компьютер, как любую другую программу. Желательно выбрать англоязычную версию. В скриншотах мы используем английский язык.

Запускаем. Выбираем Create Class Library (.NET Standard).

Обратите внимание, что в большинстве курсов по языку C#, обучение начинается с создания приложения Console App. Мы же выбрали создание Class Library, так как это нужно для подключения к ATAS.

В чем суть Class Library? Это отдельный компонент в составе большой программы. В нашем случае мы будем создавать dll файл со своими классами, чтобы потом его подключить как компонент к платформе ATAS.

Скоро увидите, как это происходит.

Выбираем имя для проекта Lesson1. Нажимаем Create.

Visual Studio запустится и сделает для нас пустой шаблон Class Library (на скриншоте ниже).

Коротко об интерфейсе. Справа (1) – окно, которое называется Обозреватель решений. Оно показывает структуру нашего проекта и его элементы (если оно у вас не отображается, его можно открыть из меню View. Там же можно открыть/закрыть другие окна).
Слева – большая область, где редактируется код программы, в данном случае – редактор класса Class1.cs.

Что есть в нашем коде после создания шаблона:

using – ключевое слово, оно означает, что мы подключаем дополнительные источники (пространства имен). Using System (2) предлагается по умолчанию, потому что там содержатся основы, которые мы наверняка будем использовать;
namespace Lesson1 – это наше пространство имен. Оно проводит как бы границу между различными частями кода, чтобы они не конфликтовали из-за одинаковых имен;
public class Class1 – заготовка для нашего класса. С# – это объектно-ориентированный язык программирования (ООП), и класс – его обязательный элемент.

Первые шаги

Установим связь с ATAS.

Для этого нужно в наш проект добавить ссылку на библиотеку ATAS.Indicators.dll, которая находится в папке с установленной платформой ATAS.

В меню Project выбираем Add References (или правой кнопкой мыши в Окне обозревателей кликаем по вкладке Dependencies).

В окне обозревателя появится ATAS.Indicators (1).

Далее редактируем код, как показано на скриншоте (2):

Пишем namespace ATAS.Indicators.Technical – потому что мы будем создавать свой алгоритм в пространстве других технических индикаторов ATAS.

Добавляем using ATAS.Indicators – создавая алгоритмы для ATAS, вы всегда будете использовать этот референс (пример – через один абзац).

Редактируем public class Example 1_1 : Indicator. В этой строке Example 1_1 значит, что мы делаем первый пример из первого урока (можно написать любое другое название, оно будет потом отображаться в списке индикаторов ATAS).
А вот двоеточие и слово Indicator имеет важный смысл. Таким образом мы обозначаем, что класс Indicator (он содержится внутри ATAS.Indicators.dll) – это “родительский” класс. И наш класс Example 1_1 наследует всё, что есть в родительском. И значит, мы получаем доступ ко всему функционалу, который разрешен наследникам класса Indicator – а это значит операции с ценами, кластерами, значениями других индикаторов и др.

Далее пишем protected override void OnCalculate(int bar, decimal value) и две фигурные скобки. Эта часть кода называется методом OnCalculate.

Метод – это, проще говоря, набор команд компьютеру для выполнения. Внутри родителя метод OnCalculate объявлен как обязательный. Когда вы добавите свой индикатор на график, платформа исполнит команды, которые вы напишите внутри фигурных скобок. И если у вас нет метода OnCalculate, то Visual Studio не даст скомпилировать код в файл dll, потому что его наличие обязательно. Иначе ATAS не будет понимать, что требуется выполнить.

Если вы все сделали правильно, внизу будет надпись No issues found (3). А когда высвечиваются ошибки, постарайтесь понять, в чем их причина. Что может пойти не так:

С# регистрозависимый язык. Это значит, что большие и маленькие буквы различаются в коде.
Фигурные скобки, точки с запятой, кавычки и другие символы – все имеет значение. Если вы забыли или потеряли что-то, Visual Studio будет вам подсказывать.

Теперь, когда у вас есть код без ошибок, давайте его скомпилируем. Для этого в меню Build выбираем Build Lesson1 (или нажимаем Ctrl+B), и в окне output должно появиться сообщение о том, что компиляция кода в файл прошла успешно.

Как видите, наш проект скомпилировался в Lesson1.dll. Мы идем в указанную папку, берем файл, копируем его в C:Users/User/Documents/ATAS/Indicators (в вашем случае путь к папке Documents может отличаться). Вставляем туда Lesson1.dll.

Запускаем ATAS, открываем график, загружаем данные по инструменту, вызываем окно менеджера индикаторов. И что там?

В списке технических индикаторов появился наш собственный Example 1_1 индикатор! (Если не находится, попробуйте форму Search).

Обратите внимание. Несмотря на то, что мы не написали практически никакого кода, наш индикатор содержит:

возможность выбора источника Source;
выбор панели для отображения;
настройки для отображения (цвет, тип линий и другие).

Все эти настройки наш индикатор унаследовал от “родительского” класса Indicator. Мы их можем изменить, но пока оставим как есть.

Если мы добавим Example1_1 на график, индикатор появится в списке добавленных, но по факту ничего не поменяется, потому что код внутри метода OnCalculate отсутствует. Нет команд для выполнения.

А если изменить панель для отображения индикатора и указать New Panel вместо Chart, то вы увидите вот что:

На нижней панели будет отображаться красная горизонтальная линия. Что за линия и почему нули?

Потому что когда вы создаете свой класс Example1_1, и наследуете его от “родительского” класса Indicator, то в ваш класс автоматически добавляется один массив данных. Он называется Датасерией. Этот массив содержит значения вашего индикатора для каждого бара.

Представим, мы добавляем индикатор Example1_1 на график, который состоит из 458 баров.

В памяти будет создана таблица, где самому раннему (левому на графике) бару компьютер присвоит номер 0, следующему – номер 1 и так далее. Последний (правый) бар получит номер 457.

А в строке Example1_1 будут храниться значения индикатора. Но так как мы не написали никакой код для их расчета, там хранятся значения по умолчанию – а это нули.

Если вы обратили внимание, то в коде у метода OnCalculate есть параметры (int bar, decimal value). Так вот:

bar – это переменная типа integer (целое число). Здесь хранится порядковый номер бара;
value – это переменная типа decimal (десятичное число). Здесь хранится значение индикатора, соответствующее этому бару.

Вероятно, это все звучит пока что сложно для новичка. Поэтому мы вернемся к вычислению значений индикатора в другой раз, а пока что сделаем что-то самое элементарное.

Первая программа

В качестве первой программы те, кто начинают изучать язык программирования C#, обычно выводят на экран сообщение “Hello, world!”.

Но так как мы делаем библиотеку для ATAS, мы будем выводить это сообщение в окно логов. Практически то же самое.

Чтобы реализовать задумку, добавляем в проект референс Utils.Common.dll из папки, где установлен ATAS. Точно так же, как мы добавляли ATAS.Indicators.dll.

Если вы все сделали правильно, то в окне Обозревателя решений у вас появится Utils.Common (как это показано цифрой 1 на скриншоте ниже).

Далее редактируем код.
Добавляем using Utils.Common.Logging; – это нужно, чтобы индикатор смог выводить сообщения в окно логов платформы ATAS.

Добавляем this.LogInfo($»Hello World 1″); в тело метода OnCalculate. Это команда для вывода в окно логов текстовой фразы “Hello World 1”.

А также создаем еще один метод protected override void OnInitialize() – скоро увидите зачем. В тело метода пишем this.LogInfo($»Hello World 2″);

Далее компилируем.

Из папки проекта копируем наш обновленный Lesson1.dll и вставляем его с заменой в папку DocumentsATASIndicators

И если у вас запущен ATAS, вы увидите уведомление от него:

Некоторые библиотеки были изменены. Перезагрузить стратегии можно в строке состояния главного окна.

Не пугайтесь, это отличнейшая новость! Когда вы обновляете свой dll в папке Indicators, вам не нужно перезапускать платформу (это может занять время).

Достаточно лишь кликнуть на эту иконку, и ATAS обновит библиотеки без перезапуска. Это сэкономит много минут, если вы часто будете делать мелкие изменения.

Далее открываем дневной график (например ED), и в окне настроек таймфрейма указываем Days Count = 5, чтобы на графике было только 5 свечек. Добавляем индикатор Example1_1 на график, и смотрим в окно логов:

5 раз вывелось “Hello World 1”, и 1 раз вывелось “Hello World 2”.

Это значит, что:

команды внутри метода OnCalculate выполняются для каждого бара, а потом метод продолжает выполняться при поступлении каждого нового тика, чтобы рассчитывать значения индикатора в реальном времени.
А метод OnInitialize выполняется только 1 раз, при инициализации индикатора. Это происходит раньше, чем выполнение команд из метода OnCalculate.

Ура, наша первая программа “Hello World” работает! Давайте теперь усложним задачу.

Вторая программа

Давайте напишем индикатор, который будет нам выводить в окно логов информацию о последнем баре – является ли он бычьим (Close>Open) или медвежьим (Close

В меню Project выберем Add Class, имя для него пусть остается Class2.cs. После добавления у вас в окне обозревателя появится новый Class (1). Кликнув по нему два раза, вы откроете редактор кода для него.

В редакторе копируем код из Example1_1 и вставляем сюда. У вас должна появиться ошибка из-за конфликта имён. Меняем название (2) класса на Example1_2, оставляем все строки using, удаляем код из метода OnCalculate, а в методе OnInitialize пишем команды для решения нашей задачи.

var candle = GetCandle(CurrentBar-1);
Что значит эта строка? Давайте прочитаем ее справа налево.

CurrentBar – это переменная, которая равна количеству свечей на графике. Но так как нумерация начинается с нуля, то последняя свеча в таблице имеет номер CurrentBar-1.
GetCandle – это метод (команда) из родительского класса Indicator. Выполняя эту команду, компьютер считывает всю доступную информацию о свече на графике под номером, который указан в скобках.
var candle – так мы объявляем новый объект для использования в программе. Когда мы объявляем новый объект, то лучше сразу ему присвоить значение. Это делается с помощью знака “равно”

И вместе – мы объявляем переменную candle и кладем в нее информацию о последней свече на графике. Теперь мы можем этой информацией оперировать. В нашем случае – делать условную конструкцию if-else (производить операцию сравнения).

Если цена Close в нашей свече больше (выше), чем цена Open – пишем в лог “Last bar is Bullish”. Иначе (если меньше или равно) – пишем в лог “Last bar is Bearish”.

Компилируем dll файл через меню Build, вставляем файл Lesson1.dll в каталог с индикаторами. Нажимаем иконку в ATAS, чтобы платформа обновила библиотеки. Открываем график:

В окне менеджера индикаторов появился Example1_2. ATAS читает каждый класс из библиотеки Lesson 1 как отдельный индикатор. Добавляем Example1_2 на график.
В окне логов появляется сообщение “Last Bar is Bullish”.
Сверяемся с графиком – все верно. Работает!

Усложняемся дальше.

Третья программа

Давайте сделаем программу, которая будет считать на графике количество бычьих и медвежьих баров.

В меню Project добавляем новый Class3. Он появляется (см. скриншот ниже) в окне Обозревателя (1), в редакторе мы меняем (2) имя класса на Example1_3 и пишем следующий код (3) внутри метода On Initialize:

Что он значит?

Мы добавили две переменные q_Green и q_Red. Обе имеют тип int (integer – целое число), и обе равны нулю. Мы будем их использовать для подсчета.

Потом идет цикл for. Этот цикл подходит, когда какую-то операцию нужно выполнить известное число раз. В нашем случае число итераций равно количеству баров на графике, которое хранится в CurrentBar. Переменная i – это счетчик, в начале он равен нулю. Но он увеличивается на 1 с каждым выполнением цикла (итерацией). Цикл будет выполняться, пока справедливо условие i < СurrentBar.

При первом выполнении цикла наш индикатор дает команду GetCandle(0), получает данные о первой (левой) свече на графике, и кладет их в объект candle. Затем сравнивает candle.Close и candle.High, и в зависимости от сравнения увеличивает q_Green или q_Red.

И так далее для каждого бара. Когда цикл заканчивается, команда LogInfo выводит в окно логов текст и значения переменных q_Green или q_Red.

Скомпилируем нашу библиотеку индикаторов, вставляем с заменой в ту же папку, кликаем иконку для обновления библиотек в ATAS, и добавим индикатор на график:

В окне логов индикатор Example1_2 написал, что последний бар – бычий. А Example1_3 написал, что всего бычьих баров – 11, а медвежьих – 12. Все верно.

Усложняемся в последний для этой статьи раз.

Четвертая программа

Давайте напишем код, который будет оценивать последовательность бычьих и медвежьих баров по продолжительности и частоте появления. Другими словами, мы хотим узнать, например, насколько вероятно, что после первого бычьего бара последует еще один бычий бар.

Но перед тем как писать индикатор, сделаем эксперимент. Возьмем код, который генерирует рандомно массив из 20 тысяч элементов, заполненный нулями и единичками. Так получим последовательность из цепочек, минимальная длина которой = 1 звено. Некоторые цепочки будут по 2, 3, 5 звеньев и более.

Вопрос – какой будет средняя длина цепочки?

В результате эксперимента, мы получаем, что среднее значение цепочки для случайно сгенерированного массива из 20 тысяч ноликов и единичек – где-то 1,96 звена.

То есть, если допустить, что 0 — медвежья свеча, а 1 — бычья, тогда на абсолютно хаотичном рынке средняя длина цепочки из бычьих / медвежьих баров будет равна = 1,96.

Эта цифра нам нужна как “эталон случайности”.

Переключаемся в Lesson1 и пишем код для нового класса Example1_4. Сначала посчитаем статистику для бычьих свечей.

Первый цикл (1) будет перебирать весь массив свечей на графике. Если мы находим начало бычьей цепочки (21-я строчка), то запускаем второй цикл (2), который считает длину каждой цепочки в bullishLine. В переменной bullishFirst накапливается количество найденных бычьих цепочек, в переменной bullishSum суммируется их общая длина.

Строки 24 и 31 нужны, чтобы предостеречься от случаев, когда алгоритм выйдет за пределы массива свечей.

Когда циклы пройдены, мы выводим (3) в окно логов информацию о количестве найденных последовательностей из бычьих свечей, общую их длину и считаем среднее значение путем деления.Аналогичный алгоритм пишем для подсчета статистики по медвежьим барам. Наверняка, мы получим не самый элегантный и профессиональный код. Но это же статья от непрофессионала для начинающих, поэтому пока что “главное – чтобы работало”.

Компилируем код, переносим в папку, запускаем на график, например акций компании Газпром (GAZP) дневного периода за несколько недель. В окне логов видим, что наш индикатор нашел:

6 медвежьих последовательностей с общей суммой 10 свечей;
6 бычьих последовательностей с общей суммой 11 свечей.

Что есть верным результатом, если учесть, что первая медвежья свеча не считается как полноценная последовательность, ведь мы не видим ее начало.

Средняя длина последовательностей:

1,66 для медвежьих свечей
1,83 для бычьих

Если мы загрузим на график данные за значительно большее число календарных дней, то обнаружится, что:

Средняя длина последовательностей для периода с лета 2017 до весны 2021:

1,86 для медвежьих свечей
1,93 для бычьих

Это очень близко к “эталону хаотичности”. Другими словами, если сегодня торги акциями GAZP закрылись ростом, то вероятность того, что завтра тоже будет бычья – условно говоря 50/50. И если вас посещали мысли простейшей стратегии в стиле “куплю завтра на открытии, если сегодня будет рост”, то с помощью ATAS и Visual Studio вы можете быстро найти ответ, насколько эта стратегия состоятельна.

А что если:

выбрать другой рынок / период?
изменить тип графика – на Delta, Range, Range XV, Reversal?
добавить trailing stop?
создать автоматическую стратегию?

Идеи появляются одна за другой. Это – чистое творчество, которым вы можете заниматься на финансовых рынках имея в распоряжении платформу ATAS и среду разработки собственных алгоритмов Visual Studio.

Вы можете начать прямо сейчас, вот ↓ архив с исходным кодом Lesson1.

Скачать архив №1

Чтобы открыть его в Visual Studio, кликните 2 раза по файлу Lesson1.sln.
А в папкеLesson1binDebugnetstandard2.0 лежит готовый Lesson1.dll, который можно сразу вставить в вашу папку C:UsersUserDocumentsATASIndicators

Бонус

А вот еще одна отличная ссылка. По ней вы можете скачать архив с набором алгоритмов для расчета популярных технических индикаторов, которые можно открыть в Visual Studio.

Скачать архив № 2

Чтобы открыть набор в Visual Studio, дважды кликните по файлу Custom Indicator Set.sln

Выводы:

Умение писать программы дает вам важное преимущество. Владея С# даже на непрофессиональном уровне, вы можете:

автоматизировать торговлю;
оптимизировать настройки стратегий;
оценивать перспективность идей.

Если все-таки создание алгоритмов на C# для ATAS окажется слишком затратной задачей по времени и усилиям, закажите их разработку у профессиональных исполнителей.

Если вам понравилась эта статья, дайте знать в комментариях. Напишите также, что бы вы хотели увидеть в следующей статье по этой теме.

Информация в этой статье не может быть воспринята как призыв к инвестированию или покупке/продаже какого-либо актива на бирже. Все рассмотренные в статье ситуации описаны с целью ознакомления с функционалом и преимуществами платформы ATAS.