Статьи. StockSharp

Plaza 2. Торговые роботы с прямым доступом.

2012-03-13T01:56:56Z

Вступление Краткое вступление о том, что такое прямой доступ к торгам для робота. Это значит, что ваш робот начинает слать торговые сигналы на биржу, минуя всех посредников (брокера, промежуточное программное обеспечение и т.д.). Часто подобный доступ ассоциируют с High Frequency Trading (далее, просто HFT) роботами, или, попросту говоря, высокочастотниками. Но HFT это не единственные “клиенты”, кому может быть удобен такой способ. Ниже ряд преимуществ и для обычного робота:

Отсутствие прослоек уменьшает технические риски.
Прямой доступ гарантирует торговлю только по правилам биржи, без накладывания дополнительных ограничений. Например, дополнительное ГО (гарантийному обеспечению), как правило.
Робот не привязан к какой-либо технологии доступа, кроме как к Plaza2.
Самая полная информация о маркет-данных. Например, order log (журнал заявок, поступающих от всех участников торгов). Модель доступа Естественно, создание роботов под шлюз биржи – это только их программирование. На языке C#, С++, Delphi и т.д. – на чем больше опыт. Биржа дает свой программный интерфейс (далее, API), с помощью которого роботы и подключаются к торгам. Бывают 2 версии этого API, под 32 и 64 битные компьютеры. Лучше использовать под 64 бита, так как тогда робот не будет ограничен потреблением памяти. Для роботов, которые используют Plaza2 как один из источников данных, а так же сложные математические расчеты, проблема с доступной памятью наиболее актуальна. Plaza2 API так же бывает однопоточной и многопоточной (STA, MTA). Лучше использовать MTA, так как в этом случае робот будет работать без временных зависаний (особенно проявляется при сильном движении на рынке), да и просто быстрее получать и отправлять данные. Написание робота под Plaza2 API требует глубоких познаний в программировании и специфике работы биржевых данных. Поэтому, для упрощения создания роботов можно использовать бесплатную библиотеку StockSharp. У нее есть ряд преимуществ перед обычным Plaza2 API:
Существенно упрощает и ускоряет процесс обучения написания роботов под Plaza2.
Позволяет включать режим эмуляции на реальных торгах (с реальной ликвидностью в стаканах).
Тестирование робота на исторических данных (единая среда как для написания робота, так и для тестирования).
Сертифицирована, что позволяет не проходить сертификацию у биржи, и получать сертификат автоматически.
Наличие стопов.
Не вносит никаких задержек, тоесть скорость работы точно такая же, как если писать робота напрямую под Plaza2 API (критично для HFT).
Открытый код.
Возможность подключать западные площадки.

Пример Вместо заключения небольшой пример того, как выглядит робот, торгующий через Plaza2.

Подключение к торгам:

var trader = new PlazaTrader();

Security rih2 = null;

trader.NewSecurities += securities =>
{
    // если RIH2 еще не появился, то пытаемся его найти
    if (rih2 == null)
        rih2 = securities.FirstOrDefault(s => s.Id == "RIH2@RTS");
};

// после успешного подключения запускаем экспорт
trader.Connected += trader.StartExport;

// подключаемся к торгам
trader.Connect();

Небольшая стратегия, торгующая спредом фьючерса на индекс РТС:


class SpreadStrategy : Strategy
{
    private Order _order;
    private bool _canProcess;
    private OrderDirections _dir;

    protected override void OnStarting()
    {
        // подписываемся на правило изменения стакана
        this
            .When(Security.MarketDepthChanged())
            .Do(ProcessDepth);

        // добавляем автозащитную стратегию (автоматически выставляет тейк + стоп)
        ChildStrategies.Add(new AutoProtectiveStrategy());

        base.OnStarting();
    }

    private void ProcessDepth(MarketDepth depth)
    {
        // заявка пока еще не исполнена
        if (!_canProcess)
            return;

        // заявка исполнилась, но не исполнились стопы
        if (PositionManager.Position != 0)
            return;

        // создаем рыночную заявку (так как на FORTS нет такого понятия как рыночная заявка, то будет использована встречная цена в стакане)
        _order = this.CreateOrder(_dir, depth.GetMarketPrice(_dir));

        // в следующий раз будем открываться в другую сторону
        _dir = _dir.Invert();

        // запретить обработу стакана до тех пор, пока заявка не исполниться
        _canProcess = false;

        this
            .When(_order.Matched())
            .Do(() => _canProcess = true);

        // отправляем на регистрацию
        RegisterOrder(_order);
    }
}

Сухов Михаил StockSharp Торговые роботы

Торговые роботы Шаг 1. Тестирование торговой системы

2012-03-18T14:34:45Z

Мне кажется, что эта статья будет больше всего интересна новичкам в алготрединге. Общаясь с людьми, недавно заинтересовавшимися торговыми роботами, я зачастую сталкивался с тем, что они не до конца понимают, что такое торговый робот и как его создают, поэтому я позволил себе немного рассуждений и пояснений на тему тестирования и создания робота. Если хотите освободить себя от моих рассуждений, переходите к главе - ТЕСТИРОВАНИЕ ТОРГОВОЙ СИСТЕМЫ, Эта часть будет полностью посвящена практике тестирования и работе с платформой.

Почему Торговые роботы.

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

ВВЕДЕНИЕ

Занимайтесь исследованием рынка

      Многие новички, приходя на рынок, не имеют четкой торговой системы для принятия решений – покупать или продавать бумагу; когда выходить из сделки, если она прибыльная; когда выходить из сделки, если он показывает убыток.  Новоиспеченный трейдер обучается прямо во время торгов – он принимает решения, основываясь на интуиции и на своём небольшом торговом опыте. Заработав на сделке, он запоминает определенный случай и старается применить его в будущем; получив убыток, он будет стараться избегать таких ситуаций. Но был ли тот случай, когда он смог заработать, действительной закономерностью или всего лишь единичным случаем из ста, когда ошибившись два раза, мы получили нужный результат? То же самое можно сказать по поводу отрицательного опыта – возможно, всё было сделано правильно, но именно в этот раз что-то сработало не так как надо, и мы не заработали. Начинающий трейдер не задается этим вопросом, и может взять за правило избегать прибыльных стратегий и следовать убыточным, основываясь на своём опыте. Причем те ситуации, которые  наблюдает новичок, складываются на основе множества факторов: новости, индикаторы (часто это не один индикатор),  наблюдение за стаканом, наблюдение за американским рынком, поведение самой цены. Человеку свойственно окружать себя тоннами информации, чтобы быть уверенным в своей правоте. Но, принимая решение на основе всех этих данных, и заработав или потеряв на сделке, как можно понять, благодаря чему именно мы заработали, и где была совершена ошибка, если мы потеряли деньги? Возникает множество сочетаний информации,  которой вы используете, вычленить нужные моменты из этой массы становиться трудно. Осознание своих ошибок и создание прибыльной торговой системы при таком подходе занимает огромное количество времени и стоит немалых денег.
         Итак, как же нам научиться зарабатывать на рынке, затратив при этом наименьшее количество времени и денег? Ответ настолько очевиден и прост, что я недоумеваю, почему этим занимается так мало людей! Чтобы научиться работать на рынке, обрести понимание рынка, надо заниматься его исследованием. Под исследованием я подразумеваю не просто наблюдение за рынком, а проверка сделанных выводов на основе прошлой истории, путем совершения бумажных сделок в прошлом, и анализом всех полученных результатов. Если вы недавно пришли на рынок, и у вас нет торговой системы, то вам необходимо придумать стратегию самим или взять за основу чужую систему. После чего требуется исследование, насколько хорошо эта система работает. Проверяя идею на истории, нам не надо ждать следующего дня, недели, месяца, чтобы увидеть первые результаты. Работая с историей, можно прогнать год торгов за несколько часов и узнать, какой результат можно ожидать от вашей системы. Так почему же этим занимается так мало людей? Проанализировав систему, вы лишаетесь иллюзий по поводу того, сможете ли вы заработать деньги, у вас не остается надежды на какое-то чудо. А также, работа на рынке лишается азарта, элемента игры. Мало кому хочется терять надежду на то, что “на рынке заработать просто”, не хочется превращать интересную игру в работу. Именно эти два желания – быстро разбогатеть и получить адреналин  являются причиной постоянного потока “мяса” на рынок. На фондовом рынке находиться не меньше мечтателей, чем в любом казино.

ПОДГОТОВКА К ТЕСТИРОВАНИЮ

Выбор бумаги для тестирования

 На фондовом рынке большое количество ценных бумаг и производных от этих ценных бумаг. У каждой бумаги своя специфика, свой характер движения. Это значит, что торговые системы, которые работают на одной бумаге, могут быть бесполезны на другой. Есть похожие по своему “характеру” бумаги, на которых будет работать один и тот же подход. Перед тем как создавать торговую систему, нам надо определиться, с каким инструментом мы будем работать. Советовать, чтобы на бумаге были сильные, резкие движения, или же наоборот, движения были плавные, нельзя. К какому рынку подойдет ваша система выясняется только тестированием. Желательно, чтобы бумага была ликвидная. Как вы позже сможете убедиться, потери при входе и выходе из-за проскальзывания значительно уменьшают прибыль и увеличивают убыток. Также стоит обращать внимание на комиссию – комиссия также может сильно сказываться на доходности системы.

Свои системы мы создаем для фьючерса на индекс РТС. Он был выбран как наиболее ликвидный инструмент на российском рынке. Проскальзывание для систем устанавливается в размере 50п для входа и 50п для выхода. Реальное проскальзывание устанавливается опытным путем.

ТЕСТИРОВАНИЕ ТОРГОВОЙ СИСТЕМЫ. ПОДГОТОВКА ПЛАТФОРМЫ

Выбор программы для тестирования стратегии

Для графического отображения исторических данных и тестирования стратегии нам понадобится программа. Выбор программы зависит от разных факторов, каждая программа имеет свои плюсы и минусы. Ниже перечислены наиболее распространенные программы для разработки систем. Omega Tradestation, Metastock, Amibroker, Wealth-Lab Developer В апреле 2012 года выходит StockSharp Studio, и вы сможете создавать и тестировать системы в одном месте. А пока мы будем тестировать систему на другой платформе.

Мы работаем на Wealth-Lab. Это один из признанных лидеров среди программ-тестировщиков. Основной его плюс – язык C#. Только ради этого плюса можно остановить свой выбор на этой программе. Данный язык – стандартный язык программирования, помощь по нему вы можете найти не столько на сайте программы wealth-lab, сколько на программистских сайтах и всемирно известных библиотеках (MSDN).

Данный язык позволяет

с лёгкостью тестировать написанный код на наличие ошибок;
писать стратегии любой сложности – от стандартных систем на свечках, до стратегий на объёмах (маркет профиль);
легко переносить протестированную стратегию в вашего робота (об этом на следующих семинарах).

После выбора программы нам необходимо загрузить котировки.

Скачать котировки можно с помощью Гидры ( http://stocksharp.com/doc/ Подробное описание работы с программой по ссылке )

Загрузка полученных данных в программу

На выходе мы получим текстовый файл с примерно следующим содержанием ТФ 5 минут, тиккер – РТС. Формат даты, как можно увидеть, ГГГГММДД, формат времени ЧЧММСС. Разделитель – запятая.

<DATE>,<TIME>,<OPEN>,<HIGH>,<LOW>,<CLOSE>,<VOL>
20090115,103000,55575.00000,55575.00000,55150.00000,55360.00000,7275
20090115,103500,55285.00000,55750.00000,55275.00000,55730.00000,6387
20090115,104000,55725.00000,55760.00000,55500.00000,55500.00000,6454
20090115,104500,55500.00000,55845.00000,55470.00000,55665.00000,3748
20090115,105000,55670.00000,55760.00000,55500.00000,55535.00000,4427
20090115,105500,55535.00000,55740.00000,55500.00000,55700.00000,3572
20090115,110000,55700.00000,56105.00000,55685.00000,56105.00000,6600
20090115,110500,56120.00000,56300.00000,56105.00000,56150.00000,7304
20090115,111000,56145.00000,56200.00000,55910.00000,55950.00000,4422
20090115,111500,55940.00000,55985.00000,55770.00000,55815.00000,4347
20090115,112000,55815.00000,55890.00000,55730.00000,55790.00000,4694
20090115,112500,55750.00000,55835.00000,55640.00000,55640.00000,3574
20090115,113000,55655.00000,55680.00000,55060.00000,55060.00000,7683

Покажем, как загрузить данные в эту программу.

При первом запуске вы увидите примерно следующую картинку.

Мы собираемся загрузить котировки, для этого нажимаем на Data Manager . Next -> Create a new DataSet. В красном прямоугольнике выделены уже существующие DataSet. Также их видно правее в окошке DataSet. Когда мы проделаем всю операцию, новый датасет появится в этом окне.

После нажатия Create a new DataSet, появится окно. У нас txt файл, поэтому выбираем ASCII Files. Next -> указываем путь к котировкам . Next -> после выбора папки в окошке появятся файлы, которые можно использовать.

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

Next -> выбираем интервал, который мы выбрали при загрузке. У нас это 5 минут. Если у вас файл с 5 минутами, то из него можно создавать файлы старшего ТФ, но не наоборот. Создавать файлы старшего ТФ из младших тоже не советуется, т.к. Велс криво склеивает. Лучше отдельно загрузить старший ТФ.
Next -> появится окно, где нам надо прописать формат для программы. В нашем случае нам надо добавить 1 - Add Field в список Field Order. Наш формат <DATE>,<TIME>,<OPEN>,<HIGH>,<LOW>,<CLOSE>,<VOL>. У нас не хватает Time. Выбираем его и двигаем с помощью кнопки 2 , все наименования в формате должны быть по порядку. В окошке 3, выбираем нужный нам формат. У нас ГГГГММДД, формат времени ЧЧММСС. В соответствующих окошках выбираем yyyyMMdd и Hmmss. Обращаю ваше внимание, формат можно выбрать из выпадающего окна, а можно напечатать самому. Нижние три окна у нас в нужном формате. Осталось поправить только в Ignore Firs Lines in File поставить 1.
На этом процедура создания DataSet завершена.

Для того, чтобы написанная на коде стратегия работала корректно, необходимо занести информацию об инструменте в Велс. Для этого заходим в Tools -> Sumbol info Manager, появится окошко. Сюда необходимо заносить данные для всех новых DataSet. Тип, устанавливаем Фьючерс (или акции, елси вы будете тестировать их). Маржа - сейчас среднее значение 9000 (минус в том, что маржа считается постоянной, и при 50 000 по РТС и при 100 000, при этом мы понимаем, что фактически она меняется). Point Value для фьючерсов 0,6. Тик равен 5 в нашем случае. Decimilars (знаков после запятой ) у нас 0 . В Symbol нужно написать точно такое же название как в DataSet. После того как мы прописали информацию, Велс будет знать как именно расчитавать профиты и лоси для системы.

Осталось задать проскальзывание. Tools -> Preferences -> Slippage. Ставим галочку для первого случая и ставим нужное нам проскальзывание. For Futures - > 10, проскальзывание в тиках = 50п.

ТЕСТИРОВАНИЕ ТОРГОВОЙ СТРАТЕГИИ. ПРИМЕР

К этому моменту у нас всё готово для тестирования стратегии. Но самой торговой системы у нас нет. Откуда же брать идеи для создания торговых систем? Лучший способ для начинающего системщика – взять за основу чужую торговую систему и попытаться поработать с ней. Позже, на основе ваших собственных наблюдений, вы будете создавать уникальные ТС.
Создание стратегии Идея Для создания ТС у нас должна быть идея, предположение, которое необходимо проверить. Наша идея основывается на наблюдении, что на рынке бывают дни с большим диапазоном, когда цена практически с самого открытия идет в одном направлении и закрывается рядом с максимальной точкой. Задача торговой системы состоит в том, чтобы поймать это движение – ударный день. Центральные условия стратегии Станет ли день ударным мы не знаем. Мы должны найти правила, соблюдение которых позволит нам получить систему с положительным матожиданием. На данном этапе, у нас есть только примерное представление, как стратегия должна работать. Все наши предположения нам предстоит проверить. Предположения

Если день ударный, то мы должны войти в него с самого утра. Если нам не удалось войти до определенного времени, день скорее всего не ударный.
вход в лонг осуществляется выше уровня открытия, вход в шорт осуществляется ниже открытия. Уровень открытия служит как фильтр – если мы находимся выше, вероятность расти больше чем вероятность упасть и наоборот.
вход в лонг осуществляется выше средней скользящей, вход в шорт осуществляется ниже средней скользящей. Средняя скользящая (157 – МА), используется как дополнительный фактор определения тренда.

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

Установка стопа

Одно из наших основных предположений было о размере стопа: так как мы собираемся взять ударный день, предполагается, что движение в нашу сторону будет сильным и без существенных откатов, что даст нам возможность входить с небольшим риском. Размер стопа будет устанавливаться в процентах. Если расстояние от дальней тени до точки входа меньше чем параметр стопа, то стоп ставится за тень. Начальный размер стопа возьмём = 0,2-0,3%, что примерно равно 300 – 450п. Выход из позиции Еще в самом начале мы сказали, что ударный день начинается и заканчивается близко к своим максимумам. Поэтому логично будет сделать выход в конце дня, в 23.45. Второй тип выхода – если цена движется не в нашу сторону, то мы выходим по стоп приказу.

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

Краткое описание стратегии

Ловим дни с большим диапазоном.

вход в лонг выше открытия дня, вход в шорт ниже открытия дня
Цена выше/ниже 157 средней.
искать точку входа до определенного времени t.
вход в лонг - бычьей моделью поглощения.
входа в шорт - медвежьея модель поглощения.
стоп = 0,2-0,3% от точки входа.
выход в конце дня.

Графическое представление Для удобства сделал картинку, как это всё должно выглядеть при реализации в тестере. Наглядно показывает выполнение центральных условий, точку входа и установку стопа.

Написание кода по алгоритму

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

Методы расчета размера позиции в системе

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

Нас интересует результаты системы, её доходность и просадка. Чтобы увидеть нужные нам результаты, необходимо зайти во вкладку Performance. Тут нужно сказать о способах, которыми расчитаываются результаты выполнения кода. При выборе разных способов, мы будем получать разные результаты на одной стратегии. Рассмотрим вкладку – Position Size.

Starting Capital – сумма с который вы будете тестировать систему.

1 – первый тип расчета позиции. Размер позиции будет постоянно выполнятся исходя из суммы указаной в fixed dollar . Если у нас ГО 7500, и в fixed dollar прописано 10 000, то размер позиции всегда будет = 1 контракту.

2- Размер позиции постоянно равен определенному количеству контрактов. 100 cоntracts в нашем случае было бы равносильно 750 000 в fixed dollars.

Эти два метода используются для того, чтобы увидеть – как было бы если вы постоянно торговали фиксированной суммой/сайзом. Третий способ отличается от передидущих двух, для тестирования систем мы используем именно его. Percent of Equity – размер позиции расчитывается изходя из имеющейся суммы, которая меняется по ходу тестирования. Если изначально у нас было 100 000 и на 50% от депозита размер позиции равен 6 контрактам, на сумме 200 000, он будет равен 12 контрактам. Тоесть в этом методе используется реинвестирование, и мы увидим какую доходность покажет система, если постоянно вкладывать заработаные деньги в систему. Также при таком подходе мы видим, какая может быть действительная просадка у системы. Этот вопрос расмотрим поподробнее.

Drawdown

Размер просадки при 1 и 2 методе расчета размера позиции в сравнение с 3 методом.

Наиболее наглядно просадку системы в графическом отображении видно во вкладке Drawdown. Просадка системы – сколько процентов мы потеряли, после максимума на счете. Впадины – отображение просадки, наибольшие впадины образовывались после последовательности убыточных сделок. На данной картинке видно, что при использовании второго метода расчета позиции, максимальная просадка в системе была в самом начале.

Картинки приведены с другой системы, не с той, что сейчас разбираем мы!

Посмотрим на эту же систему, где размер позиции рассчитывался исходя из процента размера депозита.

Сразу видно сильное различие. На обеих картинках приведена одна система. Так в чем же дело? При расчете размера позиции от депозита мы постоянно рискуем одинаковой частью депозита вне зависимости от его размера. При первом и втором методе, если система заработала некоторую сумму, например 100 000, при начальном капитале в 100 000, итого 200 000, и мы продолжает работать фиксированным количеством контрактов – 6 контрактов, при этом часть используемого депозита постоянно уменьшается, соответственно уменьшаются размер возможной просадки. При первом и втором методе размер просадки сильно зависит от того, в какой момент мы начали тестировать систему. При третьем методе, мы видим, какую просадку мы могли получить, если бы вошли в рынок на протяжении всего периода тестирования, соответственно нет такого недостатка, как момент начала тестирования.

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

Backtest Performance Report | Range – временные рамки, в которых проводилось тестирование. * Сами временные рамки задаются слева в Data Range. Data Range заданный вами может не совпадать с Range.

Net profit – сколько денег заработала система с момента начала тестирования.

Net profit % - сколько процентов заработала система с момента начала тестирования.

Annualized Gain – Средний % годовых от стратегии. * если стратегия тестируется на промежутке меньше чем год, в данной строке пишется, сколько было бы на конец года, если стратегия продолжала работать с такой доходностью, как и в доступный тестируемый промежуток.

Number of trades – количество совершенных сделок.

Average Profit – средняя прибыль за одну сделку.

Win/Loss Rate – процент прибыльных/убыточных сделок

Average Profit/Loss – средний профит/лосс по итогам всех прибыльных/убыточных сделок.

Max consecutive Winners/Losses – максимальное количество подряд прибыльных/убыточных сделок.

Maximum drawdown – максимальная просадка системы.

Итак, на картинке снизу, мы видим результаты тестирования стратегии (тестирование проводилось на промежутке 2009 – 2010 год). Результаты совсем не те, на что мы рассчитывали: огромная просадка, при практически нулевом профите. В чем проблема, почему стратегия, так плохо работает, ведь были соблюдены все условия, и код проверен, работает правильно?!

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

Сначала попробуем оптимизировать параметры системы. Параметров в нашей системе 3 (5) – МА период скользящей средней: Может так оказаться, что МА с другим периодом лучше работает. – Время, до какого времени мы ищем сигнал: Возможно, что ждать сигнала до 2х часов излишне. Параметр время разбит отдельно для коротких и длинных позиций. – Риск. Размер стопа после входа в позу: Стоп в нашем случае не превышает заданного параметра. Оптимизация параметров Важно научиться, по результатам оптимизации не только выбирать наиболее прибыльные значения параметров, но и также находить некоторые закономерности, которые могут помочь нам улучшить стратегию.

В любой системе есть параметры. Про параметры в системе следует сказать следующее: А – параметры должны иметь под собой какое-то обоснование. Например, параметр время – работать после N часов дня, не имеет смысла, т.к. если это ударный день, то мы уже должны были войти в позицию, и нас не должно было выбить по стопу. Иначе – это не ударный день, искать входов не имеет смысла. Назначение этого параметра – найти время, до которого стоит искать признаки ударного дня, и после которого становится больше ложных сигналов. Б – параметр можно переоптимизировать – подогнать под определенный промежуток времени, когда он будет хорошо работать, но в другое время будет работать намного хуже. Нужно избегать таких ситуаций. В – система должна работать прибыльно на большом наборе значений параметра. Что значит - если есть параметр с 10ю различными значениями, система должна работать на большинстве из этих значений.
Г – чем их меньше, тем лучше. Увеличение количества параметров делает систему менее устойчивой.

Проведем оптимизацию наших параметров

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

Optimization control – настройка, выбор тех параметров что мы будем тестировать. Чтобы оптимизация проходила быстрее, стоит выбирать один-два параметра и тестировать их. Чтобы удалить параметры, которые мы не хотим тестировать, выделяем его и нажимаем Remove Selected Parameter. Восстановить начальный вид можно нажав Rollback Changes. После того как мы произвели необходимые настройки, нажимаем Begin Optimization.

Results – результаты тестирования в текстовом виде.

1 Parameter Graph - на шкале отображается результат тестирования только одного параметра.

2 Parameter Graph – Отображаются сразу два параметра.

Быстрее и нагляднее всего тестировать пару параметров. Например, Время - Риск лонг, Время_S - Риск шорт, Время – Время_S . Надо понимать, что если мы изменим один параметр, то он потянет за собой другой параметр. Поэтому тестировать лучше всего как раз такие пары, где один параметр влияет на другой.

Небольшое лирическое отступление - Этот семинар пишется онлайн, я сейчас поэтапно делаю всё, о чем пишу. После этого места я уже успел написать 5 страниц с картинками, когда понял, что пошел по неправильному пути, начал оптимизацию с пары Время – Время_S – абсолютная глупость. После того, как прооптимизировал этот параметр, пришлось еще несколько раз к нему возвращаться, т.к. я изменил риск и параметр время опять изменился. Поэтому я написал замечание выше. Думай головой, как говорится, и сэкономишь много времени. У нас бывало так, что, не проверив, как следует, код, мы принимались его тестировать, потом оказывалось, что в коде ошибка и все результаты приходилось выкидывать, а это много времени.

Я еще постараюсь сделать больше ошибок, чтобы их потом не сделали вы. А сейчас пойдем по более корректному пути.

Оптимизация Время – Риск Лонг

Черными линиями отмечена область, выше которой находятся положительные параметры, ниже отрицательные. Если вы помните, я говорил, что параметр должен быть прибыльным на большем наборе значений параметра. В данном случае у нас прибыльная стратегия, если параметр от 10 часов до 14 часов. Обратите внимание, - работа до 11 часов, находится в отрицательной зоне, но не потому, что стратегия сливает, если так работать, а потому что у нас сейчас плохо работают продажи. И если работать до 11 часов по покупкам, стратегия не выходит суммарно в плюс.

Если отключить в стратегии продажи, то картинка изменится именно таким образом – работа до 14 часов находится в положительной зоне при всех значениях риска.

В стратегии УД, по нашему алгоритму, не бывает таких ситуаций, что если мы войдем в Лонг, то потом можем пропустить сигнал в шорт. Т.е. сам алгоритм, сделан таким образом, что при всех параметрах такая ситуация невозможна. Поэтому в данной стратегии можно отключить продажи, не повлияв не покупки. Я отключил продажи именно для того, чтобы вы убедились в том, что работать до 11 часов прибыльно, хотя это было ясно и по первой картинке. График оптимизации с другой стороны, чтобы лучше рассмотреть результаты по риску. Лучший параметр для риска по покупкам – 0,8-0,9%.

Какие выводы можно сделать по оптимизации Время – Риск

1 – Стратегия является прибыльной, если работать до 14 часов. При этом прибыль растет до 12 часов - посмотреть, почему прибыль начинает падать после 12 часов. 2 – При параметре время до 14 часов, на всех значениях риска, стратегия является прибыльной. Это хорошо, параметр должен быть прибыльным на большом наборе своих значений. 3 – Есть четкая тенденция, при увеличении параметра риска, прибыль растет – посмотреть, почему так происходит.

Проводя тестирование систем, и оптимизируя параметры, старайтесь понять, почему именно стратегия начинает лучше работать при тех или иных изменениях. По результатам оптимизации выбираем значение для Времени = 12 часам, для Риска по покупкам = 0,9%.

Для того чтобы понять, что именно изменилось, при новых параметрах, посмотрим Performance.

Когда мы изменили время работы с 14 часов до 12 часов, у нас уменьшилось в два раза количество сделок. При этом уменьшится количество прибыльных сделок, но оказалось лучше отказаться от половины прибыльных сделок, чтобы не получить в два раза больше лосей.

Если изменить риск с 0,2% до 0,8%, то количество сделок уменьшится еще больше, при том, что количество прибыльных сделок возрастет. Почему так произошло? Если просмотреть входы в сделки руками, то можно увидеть ситуации, когда поставим маленький стоп, мы получали после этого еще много лосей и в итоге так и не ловили УД. Если бы мы поставили больший стоп, то смогли бы поймать УД и не получили бы лосей.

Из полученных нами данных можно сделать выводы

вход в УД надо искать до 12 часов. После 12, пытаться войти в УД не имеет смысла. Этот вывод совпадает с нашим предположением, что ловить ударный день надо в самом начале. Два дополнительных часа перед терминалом не дадут никаких преимуществ.
Маленький риск не всегда хорошо. Давайте подумаем, почему вход с большим риском в данном случае оказался лучше? В стратегии УД, мы ищем импульс в определенную сторону, одним из признаков импульса – сильное открытие в какую-то сторону. Возможно второй признак, когда движение в эту сторону резкое – получаются паттерны с большими рисками. И, несмотря на то, что стоп большой, именно этот большой стоп даёт нам дополнительное смещение вероятностей. Ставить же маленький стоп, на определенную величину невыгодно, после того как произошло резкое движение, стоп часто может быть выбит на откате.

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

Посмотрим на оптимизацию со стороны времени еще раз. Видно, что основную прибыль дают сделки от 11 до 12 часов. С 10 до 11 прибыль есть, но по сравнению с периодом 11-12 часов, она незначительна. Сможем ли мы с помощью этого наблюдения улучшить стратегию для покупок еще больше?

Пропишем в коде условие, не входить до 11 часов. Результаты нашего изменения приведены на картинке выше. Количество убыточных сделок уменьшилось, количество прибыльных сделок тоже уменьшилось, но общий итог положительный – доходность выросла. Причины данного явления обсудим позже, посмотрим, как это проявляется на продажах.

Оптимизация Время – Риск Шорт

Повторяем процедуру для продаж.

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

В результате оптимизации я сделал следующие изменения в коде

время для продаж до 14 часов.
время для продаж с 11 часов
риск для продаж 0,7%

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

Performance после изменений: времени работы, рисков для покупок и продаж.

Перед тем как приступить к проверке последнего параметра – Фильтра по МА, хочу сделать небольшое отступление и рассказать одну особенность WealthLab по расчету прибыли и просадок в Performance отдельно по покупкам и продажам.

Откуда -280%

В WealthLab есть отдельный расчет просадок и прибыли по покупкам и продажам. Это сделано для удобства, чтобы можно было видеть, как они работают по отдельности. Есть одна тонкость, которая не является критической, но которую следует понимать.

Посмотрите на картинку выше, слева, в столбце по продажам, указана просадка, как работает шорт. Справа тот же столбец, только NetProfit сильно изменился, при этом мы ничего не меняли в алгоритме для продаж, и, как видно из той же картинки, количество сделок не изменилось. Дело в том, что, несмотря на то, что статистика для покупок и продаж ведется отдельно, при работе кода и появлении сигнала на продажу, вход в позицию осуществляется объемом с учетом заработанных ранее денег. После того как мы прооптимизировали алгоритм для покупок, и результаты сильно выросли, в том месте где мы раньше входили объемом в 13 лотов (пример), мы теперь будет входить объемом 26, т.к. до этого мы успели заработать с помощью покупок. При этом просадка считается от суммы, которую заработали продажи.

Оптимизация Фильтр МА

МА служит как некий индикатор тренда – если цена находится ниже средней, значит краткосрочный тренд нисходящий, наоборот – восходящий. Нам необходимо входить в позицию там, где у нас есть перевес вероятности, фильтр должен помогать нам находить этот перевес. Число 157 объясняется количеством пятиминуток за один рабочий день (сейчас время торгов изменилось, количество 5м. тоже изменилось). Посмотрим, как работает стратегия на других параметрах. Сейчас мы тестируем только один параметр, поэтому смотрим результаты в 1 Graph Parametr.

По результатам оптимизации

на всех значениях параметра стратегия работает в плюс, это хорошо.
параметр 157 один из лучших, 250 работает еще лучше, но незначительно.

Поставим значение параметра МА = 250.

Выводы после оптимизации параметров.

У нас получилось улучшить стратегию УД с помощью оптимизации параметров. Также, по графикам оптимизации мы смогли увидеть некоторые закономерности, которые помогли нам улучшить результаты системы.

Начальный Алгоритм :

вход в лонг выше открытия дня, вход в шорт ниже открытия дня
Цена выше/ниже 157 средней. +++ Параметр работает, оставляем.
искать точку входа до определенного времени t. +++ Выявили оптимальное время работы. С 11 до 12 для покупок и с 11 до 14 для продаж.
Вход в лонг по бычьей модели поглощения.
Вход в шорт по медвежьей модели поглощения.
стоп = 0,2 – 0,3% от точки входа. --- оказалось что вход с маленьким стопом не оправдывает себя. Параметр был существенно изменен.
выход в конце дня.

Интересным нововведением было – не входить в первый час торгов. Ранее мы не стали обсуждать это явление. На самом деле существует такое понятие как час дурака, это название появилось после исследования, которое показывало, что волатильностью в первый час торгов очень сильная и довольно трудно прогнозируемое. Заработать в это время можно в большей степени случайным образом, повезет/не повезет. Можете поискать в сети информацию на данную тему.

Как еще улучшить стратегию?

Хотя результаты стратегии стали намного лучше - 375% годовых, просадка оставляет желать лучшего – 43% это очень много. После того как мы исчерпали возможности оптимизации существующих параметров, вернемся к вкладке Chart, посмотрим как работает наша стратегия, возможно, после того как мы поработали с параметрами и можем отвлечься от них, мы увидим новые возможности для улучшения стратегии.

Во время просмотра Chart, мне попадались случаи подобные этому – когда у нас был хороший профит (в данном случае чистых 4,5%), а потом нас выбивало по стопу. Сразу возникает мысль – а что если сделать перенос в БУ после прохождения ценой некоторого расстояния? Или, что если мы будем фиксировать цель не в конце дня, а по математической цели, например, после 4% движения.

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

Во вкладке trades, есть два столбца MAE% и MFE%.

МАЕ% - означает, на сколько процентов цена уходила в сторону стопа.

MFE% - означает, на сколько процентов максимально цена уходила в нужную нам сторону от точки входа.

На приведенной картинке, видно, что были трейды, когда цена уходили на 4,5% , 2,3%, 3,7%, потом разворачивалась и мы получали убыток. Если просмотреть все трейды, становится видно, что такие случаи имеют место быть, поэтому попробовать запрограммировать перенос в БУ после прохождения определенного %, стоит. Также попробуем запрограммировать выход по математической цели.

Перенос стопа в БУ, после прохождения ценой N%. Если цена проходит определенный путь от точки входа, то стоп переносится в БУ. Зададим это условие как параметр, допишем в код тестера. Удостоверившись, что код работает правильно, протестируем новый параметр.

По результатам теста видно, что существенно никаких изменений, при переносе стопа в БУ нет. В таких случаях лучше отказаться от параметра, т.к. больше количество параметров делает систему менее устойчивой.

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

По результатам теста видно, что лучшие значения параметра это 9%, что, по сути, является максимальным значением. Если фиксировать прибыль при достижении 5-6-7%, к увеличению профита это не приведет, к уменьшению просадки тоже.

Вывод по новым двум параметрам Как вы смогли убедиться, смысла в переносе стопа в БУ и выходу по математической цели нет. Как было сказано в начале – вводимые параметры должны иметь под собой какое-то обоснование. Поиск точки входа в начале дня, для того чтобы поймать ударный день, имеет под собой обоснование. Выходить из позиции, потому что цена прошла определенный процент движения, не имеет под собой обоснования. Цель должна рассчитываться исходя из текущих условий, также как и перенос в БУ должен производиться после событий, которые сигнализируют о возможном развороте.

Проверка правильности написания кода.

После изменений в коде надо удостовериться, что код работает правильно. После каждого изменения в коде, надо проверять, что код работает правильно, иначе есть большая и неприятная возможность заниматься анализированием и оптимизацией неправильно работающего кода. Проверять можно полностью ручным методом, можно в помощь ручному методу использовать возможности WealthLab. Например, возьмём результаты работы кода до внесения изменений по переносу стопа в БУ и после, установив в новой версии параметр переноса на значение 10%. 10% у нас за время тестируемой истории не было ни разу, поэтому результаты работы кода в обоих случаях должны быть одинаковыми. На приведенном ниже рисунке мы видим, что все значении остались прежними, это косвенно подтверждает, что явных ошибок в измененном коде нет. Можно посмотреть во вкладке trades MAE% и MFE%. Установив параметр (например, 2%) при всех MFE больше 2%, в колонке Profit видно, что стопило нас на уровне безубытка.

Проверка кода на наличие ошибок по перфомансу.

Проверка кода на наличие ошибок по MAE – MFE.

Заключение

Торговый робот, это всего лишь автоматизация вашей стратегии. Способ реализации робота несомненно важен, от выбора платформы зависит надежность и возможность реализовать Ваши алгоритмы. Но, идея стратегии лежит на первом месте, а тестирование идеи, как мы убедились, может дать нам очень многое.

Удачи в ваших исследованиях

Горбунов Алексей

StockSharp Торговые роботы

Приложение: код для тестирования торговой системы

using System;
using System.Drawing;
using WealthLab;
using WealthLab.Indicators;
using WealthLab.Properties;
using System.Drawing;
 
namespace WealthLab.Strategies
{
	public class FirstStrategy : WealthScript
	{
		StrategyParameter paramMA;
		StrategyParameter paramTime;
		StrategyParameter paramTimeShort;
		StrategyParameter paramRisk;
		StrategyParameter paramRiskS;
		
		public FirstStrategy()
		{
			paramMA = CreateParameter("MA", 1, 1, 500, 10);
			paramTime = CreateParameter("Время", 12, 10, 19, 1);
			paramTimeShort = CreateParameter("Время_S", 11, 10, 19, 1);
			paramRisk = CreateParameter("Риск лонг", 0.2, 0.2, 1, 0.1);
			paramRiskS = CreateParameter("Риск шорт", 0.2, 0.2, 1, 0.1);
		}
        
		protected override void Execute()
		{		
			DataSeries ma = SMA.Series(Open, paramMA.ValueInt);
			PlotSeries (PricePane, SMA.Series(Open, paramMA.ValueInt), Color.Blue, LineStyle.Solid, 2);
			double sp = 0;
			double stop = 0;
              
			PlotStops();
			for(int bar = 1; bar < Bars.Count - 1; bar++)
			{
				if (Bars.IntradayBarNumber(bar) == 0)
				{
					sp = Bars.Open[bar];
				}
\
				if (IsLastPositionActive)
				{
					Position p = LastPosition;
					if (p.PositionType == PositionType.Short)
					{
						if (!CoverAtStop(bar, p, stop))
						{
							if (Bars.IsLastBarOfDay(bar))
							{
								CoverAtMarket(bar, p);
							}
						}
					}
					else //Long
					{
						if (!SellAtStop(bar, p, stop))
						{
							if (Bars.IsLastBarOfDay(bar))
							{
								SellAtMarket(bar, p);
							}
						}
					}
				}
				else
				{
					double high = Bars.High[bar];
					double low = Bars.Low[bar];

					if (!Bars.IsLastBarOfDay(bar) && high < sp)						
					{
						if (Bars.Open[bar - 1] < Bars.Close[bar - 1] && Bars.Open[bar - 1] > Bars.Close[bar] &&
							Bars.Date[bar + 1].Hour < paramTimeShort.ValueInt && Close[bar] < ma[bar] )							
						{     
							stop = Math.Max(Bars.High[bar], Bars.High[bar - 1]);
        
							double openPrice = Bars.Open[bar + 1];
							double exitPrice = stop;
                                
							if (openPrice / exitPrice  > 1 - paramRiskS.Value / 100)
							{
								RiskStopLevel = stop;
								ShortAtMarket(bar + 1);
							}
							else
							{
								stop = openPrice / (1 - paramRiskS.Value / 100);
								RiskStopLevel = stop;
								ShortAtMarket(bar + 1);
							}
						}
					}

					if (!Bars.IsLastBarOfDay(bar) && low > sp)
					{
						if (Bars.Open[bar - 1] > Bars.Close[bar - 1] && Bars.Open[bar - 1] < Bars.Close[bar] &&
							Bars.Date[bar + 1].Hour < paramTime.ValueInt && Close[bar] > ma[bar] )
						{        
							stop = Math.Min(Bars.Low[bar], Bars.Low[bar - 1]);
                                
							double openPrice = Bars.Open[bar + 1];
							double exitPrice = stop;
							
							if (exitPrice / openPrice  > 1 - paramRisk.Value / 100)
							{
								RiskStopLevel = stop;
								BuyAtMarket(bar + 1);
							}
							else
							{
								stop = (1 - paramRisk.Value / 100) * openPrice;
								RiskStopLevel = stop;
								BuyAtMarket(bar + 1);
							}
						}		
					}
				}
			}
		}
	}
}

Создание роботов с помощью S#. Введение

2012-03-18T21:58:29Z

Решил написать несколько простых статей о том, как можно разрабатывать роботов с использованием библиотеки S#. В саму библиотеку уже входят примеры, но они достаточно простые и их нельзя использовать в реальном приложении.

Предложенная архитектура робота включает следующие особенности:

Интерфейс в стиле METRO UI.
Паттерн MVVM для написания интерфейса робота.
Корректная обработка исключительных ситуаций.
Робот позволяет запускать множество различных стратегий на разных торговых системах, разных портфелях и разных инструментах, с различными параметрами, а также позволяет задавать все эти настройки в конфигурационном XML-файле (достаточная гибкость).
Хранение состояния робота.
Абсолютно компактный и тривиальный код. Приведу пример конфигурационного файла. В этом примере задается одна стратегия StrikeStrategy. Для нее задается Quik в качестве торговой системы, задается портфель, инструмент RIM2. Для получения исторических данных устанавливается провайдер, получащий данные с ФИНАМа; у него установлены свойства на получение дневных данных по инструменту RIM2. Свое состояние стратегия хранит в ветке реестра Software\FinDirector\StrikeStrategy. Размер позиции равен 20% от капитала в портфеле. Стратегия работает на 5-минутках.

<FinDirector:StrategyLoader
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:FinDirector="clr-namespace:FinDirector;assembly=FinDirector"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:System="clr-namespace:System;assembly=mscorlib"
 xmlns:Implementation="clr-namespace:FinDirector.Algo.Implementation;assembly=FinDirector.Algo"
 xmlns:Strategies="clr-namespace:FinDirector.Algo.Strategies;assembly=FinDirector.Algo">

 <FinDirector:StrategyLoader.Resources>
   <Implementation:QuikTraderBuilder x:Key="MyQuik" Title="Мой Quik"
     Path="***" Login="***" Password="***" />
   <Implementation:PortfolioSelector x:Key="MyFortsPortfolio" Title="Пенсионный фонд кота Мурзика"
     PortfolioName="***" />

   <!--RIM2 FinamSecurityCode-->
   <System:Int32 x:Key="FinamRTSCode">80996</System:Int32>
   <Implementation:SecuritySelector x:Key="fRTS"
     SecurityCode="RIM2" />
   <Implementation:SecuritySelector x:Key="Si"
     SecurityCode="SiM2" />
 </FinDirector:StrategyLoader.Resources>

 <FinDirector:StrategyLoader.Strategies>

   <Strategies:StrikeStrategy
     TraderBuilder="{StaticResource MyQuik}"
     PortfolioSelector="{StaticResource MyFortsPortfolio}"
     SecuritySelector="{StaticResource fRTS}"
     TimeFrame="0:5:0">
     <Strategies:StrikeStrategy.HistoryCandleProvider>
       <Implementation:FinamHistoryCandleProvider TimeFrame="1.0:0:0" FinamSecurityCode="{StaticResource FinamRTSCode}" />
     </Strategies:StrikeStrategy.HistoryCandleProvider>
     <Strategies:StrikeStrategy.SettingsProvider>
       <Implementation:RegistrySettingsProvider SubKey = "Software\FinDirector\StrikeStrategy" />
     </Strategies:StrikeStrategy.SettingsProvider>
     <Strategies:StrikeStrategy.VolumeSizer>
       <Implementation:MarginVolumeSizer Ratio="0.2" />
     </Strategies:StrikeStrategy.VolumeSizer>
   </Strategies:StrikeStrategy>

 </FinDirector:StrategyLoader.Strategies>

</FinDirector:StrategyLoader>

:[:::right Автор статьи — Вадим Чижов

Создание роботов с помощью S#. Часть 1. Обработка исключений

2012-03-18T21:58:32Z

Самое главное в роботе — это обработка исключений. У нас в роботе могут быть запущено множество различных стратегий, и исключение в одном из роботов или ошибка в UI потоке не должны приводить к падению всей программы. Тем не менее именно такое поведение характерно по умолчанию для .NET программы. Далее считаем, что наш робот является WPF – приложением! В качестве теста используем следующий код:

		private void Window_Loaded(object sender, RoutedEventArgs e)
		{
			Task.Factory.StartNew(ThrowException);
			ThrowException();
		}

		void ThrowException()
		{
			throw new Exception("ops!");
		}

Вначале мы кидаем исключение в отдельном потоке (а в стратегиях события могут вызываться асинхронно), а затем в UI потоке. Приложение упадет. Чтобы это исправить, необходимо сделать следующие правки. В файле App.xaml.cs написать:

		protected override void OnStartup(StartupEventArgs e)
		{
			base.OnStartup(e);

#if (DEBUG != true)
			// Don't handle the exceptions in Debug mode because otherwise the Debugger wouldn't
			// jump into the code when an exception occurs.
			DispatcherUnhandledException += AppDispatcherUnhandledException;
			AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
#endif
		}

		private void AppDispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
		{
			HandleException(e.Exception, false);
			e.Handled = true;
		}

		private static void AppDomainUnhandledException(object sender, UnhandledExceptionEventArgs e)
		{
			HandleException(e.ExceptionObject as Exception, e.IsTerminating);
		}

		private static void HandleException(Exception e, bool isTerminating)
		{
			if (e == null) return;

			Trace.TraceError(e.ToString());

			if (!isTerminating)
			{
				MessageBox.Show(string.Format(CultureInfo.CurrentCulture, "Неизвестная ошибка: {0}", e.ToString()),
					"FinDirector", MessageBoxButton.OK, MessageBoxImage.Error);
			}
		}

Тем не менее, это не спасет от крэша наше приложение при необработанных исключениях не в UI потоке. В файл app.confg необходимо добавить строки:

<runtime>
    <legacyUnhandledExceptionPolicy enabled="1" />
  </runtime>

Теперь:

приложение не будет падать при не критических исключениях (таких как OutOfMemory, StackOverflow);
мы получим сообщение об ошибке, а не проглотим его. :[:::right Автор статьи — Вадим Чижов

Создание роботов с помощью S#. Часть 2. Базовый класс для всех стратегий

2012-03-18T21:58:41Z

Все наши стратегии будем наследовать от класса StandardStrategy. Зачем он нужен? Дело в том, что все стратегии часто должны уметь делать одни и теже вещи: брать откуда-то торговую систему, портфель, инструмент, исторические свечки, хранить состояние, устанавливать размер позиции. Чтобы не решать каждый раз эти проблемы, можно сделать так:

	public abstract class StandardStrategy : Strategy
	{
		public virtual string Description { get { return Name; } }
		public ITraderBuilder TraderBuilder { get; set; }
		public IPortfolioSelector PortfolioSelector { get; set; }
		public ISecuritySelector SecuritySelector { get; set; }
		public IVolumeSizer VolumeSizer { get; set; }
		public IHistoryCandleProvider HistoryCandleProvider { get; set; }
		public ISettingsProvider SettingsProvider { get; set; }
		public Unit PriceDelta { get; set; }

		protected StandardStrategy()
		{
			PriceDelta = 0.1.Percents();
		}
	}

ITraderBuilder будет уметь волшебным образом создавать торговую систему:

	public interface ITraderBuilder : IDisposable
	{
		string Title { get; }
		ITrader Trader { get; }
		ICandleManager CandleManager { get; }
		void RunTerminal();
		ITrader BuildTrader();
		event Action IsConnectedChanged;
	}

IPortfolioSelector будет находить портфель:

	public interface IPortfolioSelector
	{
		string Title { get; }
		Portfolio GetPortfolio(ITrader trader);
	}

ISecuritySelector находить инструмент:

	public interface ISecuritySelector
	{
		string Title { get; }
		Security GetSecurity(ITrader trader);
	}

IVolumeSizer расчитывать размер позиции:

	public interface IVolumeSizer
	{
		int GetVolume(Portfolio portfolio, Security security);
	}

IHistoryCandleProvider получать исторические свечки:

	public interface IHistoryCandleProvider
	{
		List<TimeFrameCandle> GetHistoryCandles(DateTime beginDate, DateTime endDate);
	}

ISettingsProvider хранить состояние стратегии:

	public interface ISettingsProvider
	{
		string ReadSetting(string name);
		void WriteSetting(string name, string value);
	}

Представим, что у нас уже есть реалзации всех этих интерфесов (этим мы займемся позже). Как будет выглядить конкретная стратегия?

	public class StrikeStrategy : StandardStrategy
	{
		public override string Description
		{
			get { return "Стратегия для ловли ударного дня"; }
		}

		CandleToken candleToken;
		DateTime strategyStartTime;

		public TimeSpan TimeFrame { get; set; }

		public StrikeStrategy()
		{
			TimeFrame = TimeSpan.FromMinutes(5);
		}

		protected override void OnStarting()
		{
			try
			{
				Trader = TraderBuilder.BuildTrader();
				if (Trader == null)
					throw new ApplicationException(string.Format("Отсутствует трейдер {0}.", TraderBuilder.Title));
				strategyStartTime = Trader.MarketTime;

				Portfolio = PortfolioSelector.GetPortfolio(Trader);
				if (Portfolio == null)
					throw new ApplicationException(string.Format("Отсутствует портфель {0}.", PortfolioSelector.Title));

				Security = SecuritySelector.GetSecurity(Trader);
				if (this.Security == null)
					throw new ApplicationException(string.Format("Отсутствует инструмент {0}.", SecuritySelector.Title));
				Trader.RegisterQuotes(Security);

				if (VolumeSizer != null)
				{
					Volume = VolumeSizer.GetVolume(Portfolio, Security);
					this.AddInfoLog("Объем: {0}", Volume);
				}

				if (TraderBuilder.CandleManager.IsTimeFrameCandlesRegistered(Security, TimeFrame))
				{
					candleToken = TraderBuilder.CandleManager.GetToken(typeof(TimeFrameCandle), Security, TimeFrame);
				}
				else
				{
					candleToken = TraderBuilder.CandleManager.RegisterTimeFrameCandles(Security, TimeFrame);
				}

				this.When(candleToken.CandlesFinished())
					.Do<IEnumerable<Candle>>(OnCandlesFinished);
			}
			catch (ApplicationException ex)
			{
				this.AddErrorLog(ex.Message);
			}

			base.OnStarting();
		}

		void OnCandlesFinished(IEnumerable<Candle> newCandles)
		{
			foreach (Candle candle in newCandles)
			{
				OnCandleFinished(candle);
			}
		}

		void OnCandleFinished(Candle candle)
		{
			DateTime currentDate = candle.Time;

			if (candle.Time < strategyStartTime)
				return;

			...
		}
	}

:[:::right Автор статьи — Вадим Чижов

Создание роботов с помощью S#. Часть 3. Реализация интерфейсов

2012-03-18T21:58:56Z

Теперь приступим к реализации интерфейсов из 2 части статьи “Создание роботов с помощью S#. Часть 2. Базовый класс для всех стратегий”. Здесь западные специалисты рекомендуют вначале реализовывать тестовые версии интерфейсов. И писать сразу UNIT-тесты. Смотрите пример SampleEmulationTesting из библиотеки S#. Но ведь программист — это высшая форма существования разума во Вселенной, и поэтому, в принципе не может ошибаться. Сразу в бой!

QuikTraderBuilder Реализуем создание торговой системы Quik. Основной метод:

public ITrader BuildTrader()

Нужно учитывать, что метод могут одновременно вызвать из разных потоков и создавать только 1 Quik.

	public sealed class QuikTraderBuilder : ITraderBuilder, ILogSource
	{
		private object lockObject = new object();
		private Task task;
		private bool isConnected;

		public string Path { get; set; }
		public string Login { get; set; }
		public string Password { get; set; }

		public string DdeServer { get; set; }
		public string DllName { get; set; }

		private string title;
		public string Title
		{
			get { return title ?? Login; }
			set { title = value; }
		}

		public ITrader Trader { get; private set; }
		public ICandleManager CandleManager { get; private set; }
		public event Action IsConnectedChanged;

		public ITrader BuildTrader()
		{
			lock (lockObject)
			{
				if (task == null)
					task = Task.Factory.StartNew(CreateTrader);
			}
			task.Wait();
			return Trader;
		}

		private void CreateTrader()
		{
			QuikTerminal terminal = RunTerminalInternal();
			QuikTrader quikTrader;
			WriteLog(ErrorTypes.None, "Создаем шлюз взаимодействия с системой Quik.");
			if (!string.IsNullOrEmpty(DdeServer))
			{
				if (!string.IsNullOrEmpty(DllName))
					quikTrader = new QuikTrader(terminal.DirectoryName, DdeServer, DllName);
				else
					quikTrader = new QuikTrader(terminal.DirectoryName, DdeServer);
			}
			else
			{
				quikTrader = new QuikTrader(terminal.DirectoryName);
			}
			quikTrader.SecuritiesTable.Columns.Add(DdeSecurityColumns.MarginBuy);
			quikTrader.SecuritiesTable.Columns.Add(DdeSecurityColumns.MinPrice);
			quikTrader.SecuritiesTable.Columns.Add(DdeSecurityColumns.MaxPrice);
			quikTrader.ReConnectionSettings.Interval = TimeSpan.FromSeconds(10);
			quikTrader.ReConnectionSettings.WorkingTime = Exchange.Rts.WorkingTime;

			quikTrader.Connected += () =>
			{
				UpdateIsConnected(null);
				if (!quikTrader.IsExportRunning)
				{
					WriteLog(ErrorTypes.None, "Запускаем экспорт данных.");
					quikTrader.StartExport();
					Verify(quikTrader.Terminal);
				}
			};
			quikTrader.ConnectionError += ex => UpdateIsConnected(ex);
			quikTrader.Disconnected += () => UpdateIsConnected(null);

			Trader = quikTrader;
			CandleManager = new CandleManager(quikTrader);

			WriteLog(ErrorTypes.None, "Производим подключение.");
			quikTrader.Connect();
		}

		private void UpdateIsConnected(Exception ex)
		{
			var trader = Trader;
			bool isConnectedNew = trader != null && trader.IsConnected;
			if (isConnected != isConnectedNew)
			{
				isConnected = isConnectedNew;
				WriteLog(ErrorTypes.None, isConnectedNew ? "Соединение подключено." : "Соединение отключено.");
				RaiseIsConnectedChanged();
				if (ex != null) WriteLog(ErrorTypes.Error, ex.Message);
			}
		}

		private void RaiseIsConnectedChanged()
		{
			var handler = IsConnectedChanged;
			if (handler != null) handler();
		}

		public void RunTerminal()
		{
			RunTerminalInternal();
		}

		private QuikTerminal RunTerminalInternal()
		{
			QuikTerminal terminal = QuikTerminal.Get(Path);
			if (!terminal.IsLaunched)
				terminal.Launch();
			if (!terminal.IsConnected)
				terminal.Login(Login, Password);
			return terminal;
		}

		private void Verify(QuikTerminal terminal)
		{
			var errors = terminal.GetTableSettings();
			foreach (var error in errors)
			{
				string message = string.Format("Таблица {0}. {1}", error.Table.Caption, error.Error.Message);
				WriteLog(ErrorTypes.Warning, message);
			}
		}

		public void Dispose()
		{
			if (task != null)
				task.Dispose();
			if (CandleManager != null)
				CandleManager.Dispose();
			if (Trader != null)
				Trader.Dispose();
		}

		#region ILogSource
		public Ecng.Collections.INotifyList<ILogSource> Childs
		{
			get { return null; }
		}

		private Guid id = Guid.NewGuid();
		public Guid Id
		{
			get { return id; }
		}

		public event Action<LogMessage> Log;

		public string Name
		{
			get { return Title; }
		}

		public ILogSource Parent
		{
			get { return null; }
		}

		private void RaiseLog(LogMessage logMessage)
		{
			var handler = Log;
			if (handler != null)
				handler(logMessage);
		}

		private void WriteLog(ErrorTypes errorType, string message)
		{
			LogMessage logMessage = new LogMessage(this, DateTime.Now, errorType, message);
			RaiseLog(logMessage);
		}
		#endregion
	}

Создание других торговых систем оставим читателю в качестве домашнего задания.

PortfolioSelector Реализуем получение портфеля по его имени. Основной момент: ждем, когда будет инициализирована сумма на счете, т.к. она нужна для определения размера позиции.

	public class PortfolioSelector : IPortfolioSelector
	{
		private string title;
		public string Title
		{
			get { return title ?? PortfolioName; }
			set { title = value; }
		}

		public string PortfolioName { get; set; }

		public Portfolio GetPortfolio(ITrader trader)
		{
			Portfolio result = FindPortfolio(trader);
			if (result != null)
				return result;
			ManualResetEvent manualResetEvent = new ManualResetEvent(false);
			Action<IEnumerable<Portfolio>> onPortfoliosChanged = p =>
			{
				if (FindPortfolio(trader) != null)
					manualResetEvent.Set();
			};
			trader.NewPortfolios += onPortfoliosChanged;
			trader.PortfoliosChanged += onPortfoliosChanged;
			manualResetEvent.WaitOne(TimeSpan.FromSeconds(30));
			trader.NewPortfolios -= onPortfoliosChanged;
			trader.PortfoliosChanged -= onPortfoliosChanged;
			result = FindPortfolio(trader);
			return result;
		}

		private Portfolio FindPortfolio(ITrader trader)
		{
			return trader.Portfolios.FirstOrDefault(p => p.Name == PortfolioName && p.BeginAmount.Value != 0);
		}
	}

SecuritySelector Поиск инструмента по его коду. Реализация аналогична PortfolioSelector.

	public class SecuritySelector : ISecuritySelector
	{
		private string title;
		public string Title
		{
			get { return title ?? SecurityCode; }
			set { title = value; }
		}

		public string SecurityCode { get; set; }

		public Security GetSecurity(ITrader trader)
		{
			Security result = FindSecurity(trader);
			if (result != null)
				return result;
			ManualResetEvent manualResetEvent = new ManualResetEvent(false);
			Action<IEnumerable<Security>> onNewSecurities = s =>
			{
				if (FindSecurity(trader) != null)
					manualResetEvent.Set();
			};
			trader.NewSecurities += onNewSecurities;
			manualResetEvent.WaitOne(TimeSpan.FromSeconds(30));
			trader.NewSecurities -= onNewSecurities;
			result = FindSecurity(trader);
			return result;
		}

		private Security FindSecurity(ITrader trader)
		{
			return trader.Securities.FirstOrDefault(s => s.Code == SecurityCode);
		}
	}

MarginVolumeSizer Определение размера позиции по лимиту открытых позиций и гарантийному обеспечению.

	public class MarginVolumeSizer : IVolumeSizer
	{
		public double Ratio { get; set; }
		public decimal MaxCapital { get; set; }

		public MarginVolumeSizer()
		{
			MaxCapital = decimal.MaxValue;
		}

		public int GetVolume(Portfolio portfolio, Security security)
		{
			decimal capital = Math.Min(portfolio.BeginAmount.Value, MaxCapital);
			int quantity = (int)(capital * (decimal)Ratio / security.MarginBuy);
			return quantity;
		}
	}

RegistrySettingsProvider Чтение и запись состояния стратегии из реестра.

	public class RegistrySettingsProvider : ISettingsProvider
	{
		public string SubKey { get; set; }

		public RegistrySettingsProvider()
		{
			SubKey = @"Software\FinDirector";
		}

		public string ReadSetting(string name)
		{
			using (RegistryKey registryKey = Registry.CurrentUser.CreateSubKey(SubKey))
			{
				return (string)registryKey.GetValue(name);
			}
		}

		public void WriteSetting(string name, string value)
		{
			using (RegistryKey registryKey = Registry.CurrentUser.CreateSubKey(SubKey))
			{
				registryKey.SetValue(name, value);
			}
		}
	}

FinamHistoryCandleProvider Получение исторических свечей с сайта финама. Реализацию не выкладываю, т.к. много кода.

	public class FinamHistoryCandleProvider : IHistoryCandleProvider
	{
		public int FinamSecurityCode { get; set; }
		public TimeSpan TimeFrame { get; set; }

		public FinamHistoryCandleProvider()
		{
			FinamSecurityCode = 17455;
			TimeFrame = TimeSpan.FromHours(1);
		}

		public List<TimeFrameCandle> GetHistoryCandles(DateTime beginDate, DateTime endDate)
		{
			…
}

:[:::right Автор статьи — Вадим Чижов

Создание роботов с помощью S#. Часть 4. Использование XAML для загрузки стратегий

2012-03-18T21:58:59Z

В реальном приложении у нас будет много стратегий со своими параметрами, которые проще всего загрузить из XAML файла. XAML — это декларативный язык разметки. Он упрощает создание пользовательского интерфейса для нашего приложения.

К настоящему моменту мы уже проделали большую работу по разделению бизнес-логики от UI и теперь можем в форме писать кода типа:

		StandardStrategy strategy;

		StandardStrategy CreateStrategy()
		{
			var strategy = new StrikeStrategy()
			{
				TraderBuilder = new QuikTraderBuilder()
				{
					Path = "***",
					Login = "***",
					Password = "***"
				},
				PortfolioSelector = new PortfolioSelector()
				{
					PortfolioName = "***"
				},
				SecuritySelector = new SecuritySelector()
				{
					SecurityCode = "RIM2"
				},
				HistoryCandleProvider = new FinamHistoryCandleProvider()
				{
					TimeFrame = TimeSpan.FromHours(1),
					FinamSecurityCode = 80996
				},
				SettingsProvider = new RegistrySettingsProvider()
				{
					 SubKey = @"Software\FinDirector\StrikeStrategy"
				},
				VolumeSizer = new MarginVolumeSizer()
				{
					 Ratio = 0.2,
					 MaxCapital = 1000000
				},
				TimeFrame = TimeSpan.FromMinutes(5)
			};
			return strategy;
		}

		private void Window_Loaded(object sender, RoutedEventArgs e)
		{
			strategy = CreateStrategy();
		}

		protected override void OnClosed(EventArgs e)
		{
			base.OnClosed(e);
			if (strategy != null && strategy.TraderBuilder != null)
				strategy.TraderBuilder.Dispose();
		}

		private void btnStart_Click(object sender, RoutedEventArgs e)
		{
			if (strategy.ProcessState == ProcessStates.Stopped)
				Task.Factory.StartNew(strategy.Start);
		}

		private void btnStop_Click(object sender, RoutedEventArgs e)
		{
			strategy.Stop();
		}

Получилось совсем немного кода. Тем не менее в реальном приложении у нас будет много стратегий и у каждой будет куча параметров. Чтобы не зашивать их в коде, проще всего загрузить их из XAML файла, таком как в примере из статьи “Создание роботов с помощью S#. Введение”.

	public class StrategyLoader : FrameworkElement
	{
		public StrategyList Strategies { get; set; }

		public StrategyLoader()
		{
			Strategies = new StrategyList();
		}

		public static StrategyLoader Load(string location)
		{
			return (StrategyLoader)XamlReader.Load(new XmlTextReader(location));
		}
	}

	[Serializable]
	public class StrategyList : List<StandardStrategy> { }

Теперь изменим метод CreateStrategy нашей формы:

		StandardStrategy CreateStrategy()
		{
			var strategy = StrategyLoader.Load("Strategies.config").Strategies.FirstOrDefault();
			return strategy;
		}

А в файл Strategies.config поместим все настройки. В коде формы теперь нет ничего лишнего.

:[:::right Автор статьи: Вадим Чижов

Создание роботов с помощью S#. Часть 5. Использование паттерна MVVM

2012-03-18T21:59:03Z

Можно было бы уже остановиться на достигнутом. Но бородатые дяди в очках все время придумывают какие-то серебрянные пули. Видите ли, уважаемый программист не будет писать кучу кода в форме, а будет использовать паттерн MVVM (Model-View-ViewModel). Не существует какого-то единственно правильного способа реализовать этот паттерн, поэтому предлагаю самый простейший вариант. Нам понадобится интерфейс IVIew и базовый класс для ViewModel:

	public interface IView
	{
		object DataContext { get; set; }
	}

	public abstract class ViewModel : INotifyPropertyChanged
	{
		public IView View { get; protected set; }

		protected ViewModel() { }

		#region INotifyPropertyChanged Members

		public event PropertyChangedEventHandler PropertyChanged;

		protected void RaisePropertyChanged(string propertyName)
		{
			PropertyChangedEventHandler handler = PropertyChanged;
			if (handler == null) return;
			handler(this, new PropertyChangedEventArgs(propertyName));
		}

		#endregion
	}

В нашем простом приложении будет две View и две ViewModel. StrategyViewModel.cs

	class StrategyViewModel : ViewModel
	{
		public StandardStrategy Strategy { get; private set; }
		public DelegateCommand StartCommand { get; private set; }
		public DelegateCommand StopCommand { get; private set; }
		public DelegateCommand RunTerminalCommand { get; private set; }

		public StrategyViewModel(StandardStrategy strategy)
		{
			this.Strategy = strategy;

			this.StartCommand = new DelegateCommand(OnStartExecuted, CanStart);
			this.StopCommand = new DelegateCommand(OnStopExecuted, CanStop);
			this.RunTerminalCommand = new DelegateCommand(RunTerminal);
			this.Strategy.ProcessStateChanged += s =>
			{
				this.StartCommand.RaiseCanExecuteChanged();
				this.StopCommand.RaiseCanExecuteChanged();
			};

			this.View = new StrategyView();
			this.View.DataContext = this;
		}

		public bool CanStart()
		{
			return Strategy.ProcessState == ProcessStates.Stopped;
		}

		public void OnStartExecuted()
		{
			if (!CanStart())
				return;
			Task.Factory.StartNew(Strategy.Start);
		}

		public bool CanStop()
		{
			return Strategy.ProcessState == ProcessStates.Started;
		}

		public void OnStopExecuted()
		{
			if (!CanStop())
				return;
			MessageBoxResult result = MessageBox.Show(
				String.Format("Вы уверены, что хотите остановить стратегию {0}?", Strategy.Name),
				"Подтверждение", MessageBoxButton.OKCancel);
			if (result == MessageBoxResult.OK)
				Strategy.Stop();
		}

		public void RunTerminal()
		{
			MessageBoxResult result = MessageBox.Show(
				String.Format("Вы уверены, что хотите запустить терминал {0}?", Strategy.TraderBuilder.Title),
				"Подтверждение", MessageBoxButton.OKCancel);
			if (result == MessageBoxResult.OK)
				Strategy.TraderBuilder.RunTerminal();
		}
	}

StrategyView помечаем интерфейсом IView:

StrategyView.xaml.cs

	public partial class StrategyView : UserControl, IView
	{
		public StrategyView()
		{
			InitializeComponent();
		}
	}

StrategyView.xaml

    <UserControl.Resources>
        <Style x:Key="stValue" TargetType="FrameworkElement">
            <Setter Property="HorizontalAlignment" Value="Right" />
        </Style>
    </UserControl.Resources>
    <StackPanel Margin="3">
        <StackPanel Margin="5">
            <TextBlock Text="{Binding Strategy.Name}" FontSize="14" />
            <TextBlock Text="{Binding Strategy.Description}" FontSize="9"  />
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition />
                    <ColumnDefinition />
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition />
                    <RowDefinition />
                    <RowDefinition />
                    <RowDefinition />
                    <RowDefinition />
                    <RowDefinition />
                </Grid.RowDefinitions>
                <TextBlock Text="Терминал: " Grid.Row="0" Grid.Column="0" />
                <Button Grid.Row="0" Grid.Column="1"
                                        HorizontalAlignment="Right"
                                        Content="{Binding Strategy.TraderBuilder.Title}"
                                        Command="{Binding Path=RunTerminalCommand}" />

                <TextBlock Text="Портфель: " Grid.Row="1" Grid.Column="0" />
                <TextBlock Text="{Binding Strategy.PortfolioSelector.Title}" Grid.Row="1" Grid.Column="1" Style="{StaticResource stValue}"/>

                <TextBlock Text="Инструмент: " Grid.Row="2" Grid.Column="0" />
                <TextBlock Text="{Binding Strategy.SecuritySelector.Title}" Grid.Row="2" Grid.Column="1" Style="{StaticResource stValue}"/>

                <TextBlock Text="Состояние: " Grid.Row="3" Grid.Column="0" />
                <TextBlock Text="{Binding Strategy.ProcessState}" Grid.Row="3" Grid.Column="1" Style="{StaticResource stValue}"/>

                <TextBlock Text="Прибыль: " Grid.Row="4" Grid.Column="0"/>
                <TextBlock Text="{Binding Strategy.PnLManager.PnL}" Grid.Row="4" Grid.Column="1" Style="{StaticResource stValue}"/>

                <TextBlock Text="Позиция: " Grid.Row="5" Grid.Column="0"/>
                <TextBlock Text="{Binding Strategy.PositionManager.Position}" Grid.Row="5" Grid.Column="1" Style="{StaticResource stValue}"/>
            </Grid>
            <StackPanel Orientation="Horizontal" Margin="0,5,0,0" HorizontalAlignment="Center">
                <Button x:Name="btnStartStrategy" Content="Старт" Command="{Binding Path=StartCommand}" Margin="2,0,0,0" />
                <Button x:Name="btnStopStrategy" Content="Стоп" Command="{Binding Path=StopCommand}" Margin="2,0,0,0" />
            </StackPanel>
        </StackPanel>
    </StackPanel>

MainViewModel.cs

	class MainViewModel : IDisposable
	{
		public ObservableCollection<StrategyViewModel> Strategies { get; private set; }
		public ILogListener LogView { get; private set; }
		private LogManager LogManager;

		public MainViewModel()
		{
			Strategies = new ObservableCollection<StrategyViewModel>();
			CreateLoggers();
		}

		private void CreateLoggers()
		{
			LogManager = new LogManager();

			LogView = new StockSharp.Xaml.Monitor();
			LogManager.Listeners.Add(LogView);

			var fileListener = new FileLogListener(
				string.Format(CultureInfo.InvariantCulture, "{0:yyyyMMdd}.txt", DateTime.Today));
			LogManager.Listeners.Add(fileListener);

			if (!string.IsNullOrEmpty(Settings.GoogleLogin))
			{
				var smsListener = new SmsLogListener(Settings.GoogleLogin, Settings.GooglePassword);
				smsListener.Filters.Add(LogListener.AllErrorFilter);
				LogManager.Listeners.Add(smsListener);
			}
		}

		public void Dispose()
		{
			if (LogManager != null)
				LogManager.Dispose();
			if (Strategies != null)
			{
				foreach (ITraderBuilder traderBuilder in Strategies.Select(s => s.Strategy.TraderBuilder).Distinct())
				{
					if (traderBuilder != null)
						traderBuilder.Dispose();
				}
			}
		}

		public void LoadStrategies()
		{
			StrategyLoader strategyLoader = StrategyLoader.Load("Strategies.config");
			Strategies.Clear();
			foreach (StandardStrategy strategy in strategyLoader.Strategies)
			{
				LogManager.Sources.Add(strategy);
				StrategyViewModel strategyModel = new StrategyViewModel(strategy);
				Strategies.Add(strategyModel);
			}
			foreach (ILogSource logSource in strategyLoader.Strategies
				.Select(s => s.TraderBuilder).OfType<ILogSource>().Distinct())
			{
				LogManager.Sources.Add(logSource);
			}
		}
	}

MainWindow.xaml.cs

	public partial class MainWindow : Window
	{
		private MainViewModel viewModel;

		public MainWindow()
		{
			InitializeComponent();
			this.Loaded += Window_Loaded;

			this.viewModel = new MainViewModel();
			this.DataContext = viewModel;
		}

		private void Window_Loaded(object sender, RoutedEventArgs e)
		{
			viewModel.LoadStrategies();
		}

		protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
		{
			base.OnClosing(e);
			MessageBoxResult result = MessageBox.Show(
				"Вы уверены, что хотите завершить работу?",
				"Подтверждение", MessageBoxButton.OKCancel);
			if (result != MessageBoxResult.OK)
				e.Cancel = true;
		}

		protected override void OnClosed(EventArgs e)
		{
			base.OnClosed(e);
			if (viewModel != null)
				viewModel.Dispose();
		}
	}

MainWindow.xaml

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <ScrollViewer Grid.Row="0" VerticalScrollBarVisibility="Auto">
            <ItemsControl ItemsSource="{Binding Path=Strategies}">
                <ItemsControl.ItemsPanel>
                    <ItemsPanelTemplate>
                        <WrapPanel ></WrapPanel>
                    </ItemsPanelTemplate>
                </ItemsControl.ItemsPanel>
                <ItemsControl.ItemTemplate>
                    <DataTemplate>
                        <ContentControl Content="{Binding View}" />
                    </DataTemplate>
                </ItemsControl.ItemTemplate>
            </ItemsControl>
        </ScrollViewer>

        <ContentControl Grid.Row="1" Content="{Binding LogView}" />
    </Grid>

Остается добавить к приложению стили и оно станет выглядеть как в статье “Создание роботов с помощью S#. Введение”.

Простейшая стратегия долгосрочного инвестирования.

2012-06-07T21:18:52Z

Попробуем сделать простейшую стратегию для долгосрочного инвестирования. В качестве рабочего будем использовать дневной таймфрейм. Вся суть стратегии будет заключаться в простейшей идее, что падение рынка обычно связано с более высокой волатильностью, чем в среднем. Соответственно, мы будем покупать, когда волатильность ниже среднего, и выходить из лонга, когда она повышается. В качестве меры волатильности будем использовать размах бара High - Low. Остается один вопрос: как измерить долгосрочное среднее волатильности? Можно использовать среднее (то есть скользящую среднюю, взятую за определенный период). Но так как мы имеем дело с распределением с тяжелыми хвостами, среднее будет плохой оценкой центра распределения. Поэтому будем использовать робастную оценку центра распределения - в нашем случае это будет медиана или, более точно, скользящая медиана, взятая с большим окном. Наши рассуждения напрямую транслируются в код на WealthLab:

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using WealthLab;
using WealthLab.Indicators;

namespace WealthLab.Strategies
{
	public class MyStrategy : WealthScript
	{
		private StrategyParameter smaPeriod;
		public MyStrategy()
		{
			smaPeriod = CreateParameter("Range Sma Period", 1, 1, 50, 1);      
			
		}
		
		protected override void Execute()
		{
			DataSeries range = High - Low;
			DataSeries rangeSma = new WealthLab.Indicators.SMA(range, smaPeriod.ValueInt, "sma");
			DataSeries signal = rangeSma -  new WealthLab.Indicators.Median(range, 200, "median");
			
			for(int bar = 0; bar < Bars.Count; bar++)
			{				
				if (IsLastPositionActive)
				{
					//code your exit rules here
					if (signal[bar] > 0)
						SellAtMarket(bar + 1, LastPosition, "sell");
				}
				else
				{
					//code your entry rules here
					if (signal[bar] < 0)
						BuyAtMarket(bar + 1, "buy");
				}
			}
		}
	}
}

Единственный параметр - это длина скользящей средней для сглаживания текущего сигнала High-Low (полный аналог ATR). В дальнейшем мы будем его использовать, лишь чтобы сократить количество входов. Установим сначала smaPeriod = 1, то есть не будем использовать сглаживание сигнала. Получим:

Судя по полученным параметрам бэктеста, идея содержит какое-то статистическое преимущество. Теперь попробудем уменьшить количество сигналов, увеличив период фильтрации High-Low. Сначала проверим робастность этого параметра, то есть убедимся, что параметры стратегии сохраняются на широком диапазоне значений параметра. После этого возьмем его, к примеру, равным 12. И как результат получаем:

Как видно, стратегия bye & hold принесла за рассматриваемый период нулевую доходность, в то время как наша простейшая система показала небольшую, не совсем стабильную, но прибыль.

Создание простого привода на S#

2012-05-24T21:50:34Z

Бесплатная библиотека StockSharp предоставляет широкие возможности при разработке торговых роботов различной сложности. Но самое трудное для многих пользователей - сделать первые шаги при разработке своего робота. Поэтому представляем вашему вниманию статью-инструкцию по созданию простого привода для терминала QUIK с использованием S#.API.

Для создания простого привода нам понадобится:

Quik;
Библиотека S#;
Visual Studio Express;
Немного навыков программирования.

**:::center Подготовка рабочего места

Для тех, у кого не стоит бесплатный Visual Studio Express С#, скачиваем и устанавливаем.
Cкачиваем библиотеку с официального сайта StockSharp, либо - по прямой ссылке на последнюю доступную версию. Разархивируем в какую-нибудь папку, чтобы не забыть потом.
Устанавливаем Quik (демо-версию можно получить с официального сайта). Получаем логин, пароль, ключи, настраиваем Quik соответствующим образом.

После установки Quik, его нужно настроить для работы со S#. Для этого нужно проделать 3 базовых шага:

1) Включить обработку внешних транзакций. "Торговля" → "Внешние Транзакции" → "Начать обработку" и поставить галочку "Запускать процесс обработки внешних транзацкий автоматически"

2) Далее нужно открыть соответствующий Wnd-файл с настройками: "Настройки" → "Загрузить настройки из файла" → выбрать wnd-файл по пути "Разахивированная папка"\Samples\Quik\info.wnd

3) Далее настраиваем счета : "Торговля" → "Настройка счетов" → добавить все счета в выбранные счета депо.

4) В итоге можно настроить окошки - подтянуть их, уменьшить, но названия столбцов менять нельзя, так же как и удалять их. У разных брокеров (квиков) есть особенности , стоят определённые фильтры на таблицах "Мои сделки", "Мои заявки". Нажав правой кнопкой мышки на таблицу "Мои сделки", выделить все. Аналогично и в таблице “Мои заявки”.

Добавьте торгующийся на данный момент инструмент в таблицу "Инструменты"; по нему в дальнейшем мы будем отправлять заявки.

**:::center Создание торгового привода

Открываем Visual Studio. Создаём новый проект → "Приложение Wpf". Настраиваем наш проект на работу S#:

Правой кнопкой мыши на "Проект" → "Свойства" и меняем "Требуемая версия NetFrameWork" (Net FrameWork 4 Client Profile ) на просто Net FrameWork 4(после этого меняется целевая среда разарботки).
Добавляем нужные библиотеки в наш проект "Ссылки" → "Добавить ссылку" → "Обзор".
Выбираем нужные нам библиотеки, которые лежат в "Разахрихированая папка"\References: 1)StockSharp.Quik 2)StockSharp.BusinessEntites 3)StockSharp.Algo 4)Ecng.Common 5)Ecng.ComponentModel 6)Ecng.Xaml
Прописываем соответсвующие using на наши библиотеки в классе MainWindow.xaml.cs

using System.Windows;
using StockSharp.Quik;
using Ecng.Xaml;
using StockSharp.BusinessEntities;

Заходим в MainWindow.Xaml, создаём соответсвующие кнопки и другие элементы на форме нашего приложения, перетягивая их из панели элементов. Получаем следующую форму:

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

Прописываем код под кнопку подключения. Это простой код демонстрирующий подключение и выгрузку данных из Quik в асинхронном режиме. Теперь осталось дополнить код выводом информации на главную форму, то есть сделать вывод в наши выпадающие списки "Портфели" и "Инструменты".

//обьявляем переменную
        private QuikTrader _trader;
        /// <summary>
        /// Подключение к квику
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Connect_Click(object sender, RoutedEventArgs e)
        {
            //создаём квик трейдера, передавая ему сразу место расположения нашего терминала
            _trader= new QuikTrader(QuikTerminal.GetDefaultPath());
            //подписываемся на событие подключения, как только подлючимся, сразу запустим Экспорт
            //Connect- просто подключение к потоку
            //StartExport- получение он-лайн данных из квика Инструменты,Заявки , Портфели и так далее
            _trader.Connected += () => _trader.StartExport();
            // подключаем квик 
            _trader.Connect();

        }

Дописываем графический вывод на нашу форму в выпадающие списки:

private void Connect_Click(object sender, RoutedEventArgs e)
        {
            //создаём квик трейдера, передавая ему сразу место расположения нашего терминала
            _trader= new QuikTrader(QuikTerminal.GetDefaultPath());
            //подписываемся на событие появление новых инструментов
            //оно сработает когда включится экспорт 
            _trader.NewSecurities += securities =>this.GuiAsync(()=>//GuiASync используется чтобы выводить графику из другого потока
                                                                    {
                                                                        //заполняем коллекцию у нашего выпадающего списка (ComboBox)
                                                                        Securitites.ItemsSource = _trader.Securities;
                                                                    });
            //подписываемся на событие появления новых портфелей
            //сработает после запуска экспорта
            _trader.NewPortfolios += portfolios =>this.GuiAsync(()=>
                                                                    {
                                                                        //заполняем коллекцию у нашего выпадающего списка (ComboBox)
                                                                        Portfolios.ItemsSource = _trader.Portfolios;
                                                                    });
            
            //подписываемся на событие подключения, как только подлючимся, сразу запустим Экспорт
            //Connect - просто подключение к потоку
            //StartExport- получение онлайн данных из квика Инструменты, Заявки, Портфели и так далее
            _trader.Connected += () => _trader.StartExport();
            // подключаем квик 
            _trader.Connect();

        }

Запускаем проект (F5), нажимаем на кнопку "Подключиться" (в это время у нас уже работает Quik, который подключен к котировкам). После этого наш робот включает эскпорт DDE в Quik и через некоторое время мы получаем заполненные выпадающие списки в нашем проекте.

Остается дописать функционал под две оставшиеся кнопки "Купить", "Снять все заявки":

"Купить" - отправляем заявку (портфель и инструмент берется из выпадающих списков) по той цене, которая будет указана в нашем текстовом окне;
"Снять все заявки" - снимаем все выставленные нами заявки. Код для отправки заявки:

private void Buy_Click(object sender, RoutedEventArgs e)
        {
            //создаём ордер
            //заполняем его нужными свойствами
            // портфель и инструмент вынимаем из выпадающих списков
            //цену для отправки заявки вынимаем из тесктового окна
            var order = new Order
                            {
                                Trader = _trader,
                                Portfolio = (Portfolio)Portfolios.SelectedItem,
                                Security = (Security) Securitites.SelectedItem,
                                Volume = 1,
                                Price = decimal.Parse(PRICE.Text),
                                Direction = OrderDirections.Buy
                            };
            //регистрируем ордер
            _trader.RegisterOrder(order);
        }

Код для снятия всех заявок:

private void CancelOrders_Click(object sender, RoutedEventArgs e)
        {
            //отменить все заявки
            _trader.CancelOrders();
        }

Пример работы простого привода:

Скачать исходники также можноздесь.

**:[:::center Видео-урок по созданию простого торгового робота с использованием библиотеки StockSharp:

Автор статьи: Самунджян Артём

Торговые роботы для QUIK или QPILE vs S#

2012-08-27T19:43:03Z

В QUIK есть встроенный язык программирования qpile, на котором можно писать торговых роботов. Трудно выделить какие-либо существенные плюсы в этом языке программирования: роботы работают медленно; если Вы сделали ошибку в алгоритме, найти её будет крайне сложно; нельзя реализовать интерфейс пользователя; возможности языка ограничены; зависания стратегии = низкая надежность. Кроме того, qpile не используется нигде кроме QUIK. К сожалению, язык программирования qpile – это первое, на что обратит внимание трейдер, решивший запрограммировать свою торговую систему, поскольку qpile находится в непосредственной близости к терминалу QUIK. Но если подойти к вопросу более ответственно и потратить своё время на выбор платформы, можно увидеть, что есть лучшие решения, превосходящие qpile по всем параметрам.

Среди языков программирования, самый удобный для создания торговых роботов - C# (разработан Microsoft). C# используется в: WealthLab, StockSharp, QuantDevelop, OpenQuant. Возможности языка покрывают все потребности алготрейдера, а распространение языка предоставляет Вам свободу выбора.

На языке С# написана библиотека для создания торговых роботов StockSharp. Что такое библиотека? Представьте себе, что Вам нужно написать код, который будет выставлять заявку на рынок или совершать любое другое действие. Код будет состоять из 100 строк, на написание и проверку которых уйдет N-е количество времени. Теперь представьте, что кто-то уже написал этот код и теперь Вы можете воспользоваться им, написав одну строчку.

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

Итак, библиотека – это множество кодов, написанных профессиональными программистами. Библиотека StockSharp содержит коды, которые нужны для разработки торгового робота (подсоединение к терминалу, выставление заявки, индикаторы и т.д.). Таким образом, Вы экономите время на написание и отладку кода. Раньше только профессиональные программисты могли воспользоваться преимуществами языка программирования. С появлением Stock#, программирование торговых роботов стало доступнее.

S# это:

Библиотека, независимая от торговых систем.
Робот под одну торговую систему с минимальными изменениями переносится на другую (торговые роботы для Quik, SmartCOM, Plaza, AlfaDirect).
Библиотека S# работает со всеми брокерами.
Библиотека бесплатная.

Ознакомиться с документацией к библиотеке S#.

Вам также могут оказаться интересны статьи: Примеры работ, выполненных с использованием библиотеки StockSharp. Торговые роботы. С чего начать. Общие вопросы.

Торговые роботы. С чего начать. Общие вопросы

2012-08-27T19:43:05Z

Перед человеком, решившим встать на путь алготрейдера, встает важный вопрос: какую площадку для тестирования и создания торгового робота выбрать? Согласитесь, будет обидно потратить несколько месяцев на освоение инструмента, после чего осознать его непригодность. В этой статье я постараюсь затронуть все основные направления в роботостроении и ответить на большинство вопросов начинающего алготрейдера.

**:::center Учить язык программирования или использовать визуальный редактор?

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

«В чем причина провальности таких решений? В направлении. Людям, которые только изучают программирование, визуальный редактор только навредит. Он дает первоначальный вау фактор, который исчезает уже ко второму дню использования. Через неделю, код будет выглядеть как на картинке. И вот тут как раз и происходит крах такого подхода. Они были призваны упростить программирование. А вместо этого, происходит усложнение. И более того, код в текстовом файле начинает занимать значительно меньше места, чем вся эта мега-диаграмма, не влезающая аж 8 мониторов. А уж как ее тестировать - у-у-у-у. Это отдельная тема мазохизма.» **:::center Выбор языка программирования

Изучить язык программирования будет сложнее, чем освоить визуальный редактор, но если у Вас серьёзные намерения, это правильный выбор. Но языков программирования много, какой выбрать? Основные языки, на которых пишут роботов: • QPILE – встроенный язык в терминале QUIK • VBA Excel • Delphi • C#

:[**:::center QPILE

Трудно выделить какие-либо существенные плюсы в этом языке программирования, другие языки существенно превосходят его по функциональности, возможностям и другим параметрам. Его широкое распространение связанно с тем, что до недавнего времени не существовало альтернативы, а также с тем, что терминалом QUIK пользуются большинство трейдеров и, соответственно, qpile на слуху. Единственный плюс, вытекающий из популярности qpile – довольно просто получить тех. поддержку на форумах. На qpile можно написать робота, тестировать торговые стратегии нельзя. Я не советую использовать этот язык. :[**:::center

VBA Excel

В целом те же замечания, что и в qpile. Функционал чуть шире, но пользуются им небольшое количество трейдеров, а значит тех. поддержку получить сложно.

Delphi

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

:[:::center C#

С# (разработан Microsoft) выделяется по всем параметрам. Функциональность, простота и надежность сделали его фаворитом для большинства платформ для тестирования торговых стратегий. WealthLab, TS-Lab в качестве внутреннего языка программирования используют именно его. Возможность написания библиотек на C# существенно ускорила и облегчила написание торгового робота. Что такое библиотека? Представьте себе, что Вам нужно написать код, который будет выставлять заявку на рынок. Код будет состоять из 100 строк, на написание и отладку которых уйдет N-е количество времени. Теперь представьте, что кто-то уже написал этот код и теперь Вы можете воспользоваться им, написав одну строчку. Библиотека – это множество кодов, написанных проф. программистами. Библиотека StockSharp содержит все коды, которые нужны для разработки торгового робота. Таким образом, Вы экономите время на написание и отладку кода. Раньше каждый писал библиотеку для себя, для этого нужно иметь приличный опыт программирования. Теперь любой может использовать плюсы языка C#, не являясь проф. программистом. На нашем форуме оперативно отвечают на вопросы, Вы всегда сможете получить тех поддержку от первых лиц. Что мы имеем в итоге: выучив C# у вас нет привязки к какой-то одной платформе, язык используется повсеместно. На нем можно тестировать торговые стратегии как интрадей (WeathLab), так и HFT (StockSharp). Написание торговых роботов - можно самостоятельно писать свой код, можно воспользоваться библиотекой S#.

Рекомендуем ознакомиться: Небольшая статья о выборе языка программирования.

**:[:::center Создание торговых роботов условно можно разделить на два этапа:

1 — тестирование торговой системы; 2 — воплощение торговой системы в виде робота.

**:::center

Тестирование торговой стратегии

Тестирование торговых систем призвано доказать прибыльность системы, найти её минусы и подсказать способы улучшить систему. Я выделю три основных платформы для тестирования: WealthLab — cтабильная, удобная в использовании платформа. Подойдет для тестирования внутридневных стратегий, среднесрочных, долгосрочных, тестирования на портфеле бумаг. WLD - oдно из лучший решений на данный момент. В WLD — нельзя тестировать HFT стратегии. Внутренний язык программирования в WLD — C#. TSLab — тот самый визуальный редактор, о котором мы говорили в самом начале. Алгоритм представлен в виде блок-схемы. Разработка относительно новая, поэтому имеются некоторые проблемы с тестированием и расчетами, хотя в последнее время проблем стало значительно меньше. Основной минус визуальных редакторов мы уже затрагивали. Если выбирать между TSLab и WLD, выбор очевиден. StockSharp – возможность тестирования HFT стратегий. В скором времени появится полноценная графическая среда (StockSharp Studio) для тестирования всех видов систем. Другие платформы для тестирования: Metastock, amibroker, OpenQuant.

Дорогие друзья, время не стоит на месте, торговые платформы меняются и развиваются. Сегодня октябрь 2013 года и мы представляем вам новый, пересмотренный подход к выбору платформы для торговых роботов. Мы стараемся давать вам полную информацию, чтобы вы смогли сделать справедливый выбор, поэтому предоставляем вам ссылки на следующие статьи:

Какую платформу для торговых роботов выбрать: TSLab,WealthLab,StockSharp?
StockSharp (СтокШарп) – Торговые роботы. Стоит ли выбирать? В этих статьях вы ознакомитесь с текущим положением дел. Мы умеренно сообщаем вам об этом сейчас, когда вы уже прочитали половину статьи, с той целью, чтобы вы прочувствовали, как меняются технологии с течением времени. Но, с другой стороны, вы можете убедиться, что наш основной совет – изучать C# – остался прежним. Этот совет становится даже более актуальным, т.к. и в TSLab API используется C#!

**:::center 2. Воплощение торговой системы в виде робота

Торговые роботы реализуются двумя путями: 1 — тестирование стратегии на WealthLab (WLD), а реализация робота на qpile. Минус такого подхода – надо знать два языка программирования: C# для WLD и qpile для QUIK. 2 — к программе для тестирования торговых систем приделывается коннектор.

Второй путь: Робот пишется на платформе для тестирования торговых систем и подсоединяется к торговому терминалу через коннектор. Удобство такого метода должно состоять в том, что после тестирования торговой стратегии Вы можете сразу вводить робота в эксплуатацию. Так задумывалось, но не всегда так бывает. Возникают различные сложности, природа которых лежит в том, что программы для тестирования стратегий создавались для тестирования, а не использования их в виде торговых роботов. Например, отсутствие обратной связи, когда после выставления заявки нельзя проверить её статус – была она исполнена или не дошла из-за разрыва интернета. Сами коннекторы чаще всего самописные, что делает связку "торговый робот/платформа" нестабильной. Для 6го WealthLab есть коннектор, написанный брокерской компанией Церих; коннектор платный - 50 рублей в день. Издержки, сопоставимые с платой за Интернет, и есть какая-то уверенность стабильной работы. Все же этот путь тупиковый: программа для тестирования стратегий накладывает сильные ограничения на функционал робота, поэтому вернемся к первому способу, когда реализация торгового робота осуществляется на языке программирования. В этом случае функционал робота ограничивается лишь возможностями языка программирования, а значит, почти не ограничен.

Первый путь: Совсем не обязательно знать два языка программирования, если Вы прислушались к совету и выбрали C#. Тестирование торговых систем идет на WLD, там пишется код на C#, потом этот же код с минимальными изменениями переносится в инфраструктуру робота, написанного на C# с использованием библиотеки StockSharp. Правильный выбор языка позволяет использовать нам лучшие решения. Функционал робота неограничен по сравнению с первым случаем. Есть возможность обратной связи (отслеживания состояния робота), автоматическое переподключение при разрыве и т.д. Ниже показан пример интерфейса торгового робота, написанного с использованием библиотеки StockSharp.

Из этого окна осуществляется запуск и навигация по роботу. При нажатии кнопки "Старт" робот запускают все прописанные торговые терминалы, логинится и выполняет подключение к данным.

Если нужно добавить новый терминал – заходим в настройку.

Редактирование настроек робота без вмешательства во внутренний код.

Робот отчитывается о своих действиях, пересчет алгоритма идет с заданной вами частотой.

Итог

Знание языка программирования открывает перед нами широкие возможности. Выбор С# позволяет использовать лучшие решения и не привязываться к определенному продукту. Практически все продукты, связанные с тестированием ТС и созданием роботов, используют C#. Тестирование стратегии лучше всего делать в WealthLab. Реализовывать робота лучше всего, используя библиотеку S# - мы экономим своё время и упрощаем задачу написания торговых роботов.

**:::center Успехов на рынке! Торговые роботы Stock# Горбунов Алексей

Ознакомиться с документацией к библиотеке S# можно здесь.

Гидра умерла, да здравствует Гидра 2.0

2012-10-22T02:06:00Z

Те, кто постоянно следят за изменениями в Гидре, сразу стали замечать происходящие изменения. Но мы не делали анонса перед большой аудиторией, потому-что хотели довести работу до логического завершения. И вот, наконец-то, мы официально объявляем о рождении Гидры 2.0 !

Появление новой версии не означает, что мы остановимся на достигнутом. Наоборот, мы ждем от Вас отзывов, новых предложений, отчетов о возможных ошибках и другой обратной связи.

Старая Гидра честно выполняла все возложенные на нее задачи, но её дизайн был, что называется, не интуитивный. В какой-то момент мы поняли, что хотим помочь нашим пользователям в освоении программы, хотим сделать её более удобной и понятной. Поэтому летом 2012 года командой StockSharp было принято решение модернизировать Гидру.

Первая Гидра имела одно единственно окно, в котором отображались все возможные инструменты из различных источников. Все это приводило к некоторой неразберихе в данных. Как это выглядело, вы можете увидеть на картинке ниже.

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

Было сделано огромное количество мелких и средних изменений: все изменения перечислять нет смысла, но все они стали неотъемлемой частью Гидры 2.0

Вот некоторые из изменений:

Источники открываются в отдельных вкладках
Убрали избыточные настройки, как следствие - упростилась настройка источников
Добавился визуальный лог программы
Визуальное отображение статуса работы
Упростили добавление новых инструментов в источник
Упростили редактирование инструмента
Добавлена возможность автостарта
Убрали принудительное сворачивание в трей
Загрузка нового типа данных из QUIK - изменения инструментов

Произошли не только внешние изменения Гидры: мы доработали функциональную часть программы. Эта часть осталась незаметной пользователю, но повлияла на производительность Гидры и на её возможности.

Скачать последнюю сборку Гидры Если у Вас возникнут вопросы по работе с программой, вы можете ознакомиться с нашей документацией.

Отладка стратегий WealthLab в Visual Studio

2012-05-14T14:53:51Z

Запускаем Visual Studio, переходим File — New project. Visual C# — Class library, не забываем поставить .NET Framework 2.0.
Добавляем ссылку на сборку WealthLab'a (WealthLab.dll). Add Reference — Browse — ищем папку с WLD (как правило, это c:\Program Files (x86)\Fidelity Investments\Wealth-Lab Pro 5\ ). Выбираем WealthLab.dll. Жмем OK.

Создаем два класса.Один ИмяКлассаScript (переименовываем Class1.cs), другой ИмяКлассаHelper (добавляем новый — правый клик по имени проекта, Add — Class). В диалоговом окне подтверждения переименования жмем ОК. Получается так:

Открываем ИмяКлассаScript. Добавляем директиву using WealthLab, наследуем класс от WealthScript, имплементим метод Execute() (можно нажать хоткей ALT-SHIFT-F10 затем ENTER). Должно получиться так:

Открываем ИмяКлассаHelper. Добавляем директиву using WealthLab, наследуем класс от StrategyHelper, имплементим все свойства (можно нажать хоткей ALT-SHIFT-F10 затем ENTER). Заполняем свойства:

Name — имя стратегии;
Guid ID — правой кнопкой по имени проекта — свойства (последняя в списке), открывается окно свойств — вкладка Application — справа конпка «Assemble Information» — копируем GUID. Также здесь заполните свойство Description (например, укажите имя стратегии — Test Strategy.) Возвращаемся назад, вставляем скопированное;
Author — автор;
WealthScriptType — здесь вы должны указать тип вашей стратегии (ИмяКлассаScript).
Description — описание стратегии;
CreationDate — дата создания;
LastModifiedDate — дата последней модификации стратегии.

Должно получиться так:

Правой кнопкой по имени проекта — свойства (последняя в списке), открывается окно свойств — вкладка Build, свойство Output Path — указываем путь к папке WLD — c:\Program Files (x86)\Fidelity Investments\Wealth-Lab Pro 5\
ИмяКлассаScript — пишем стратегию в методе Execute() — например, пересечение MA. Должно получиться так:

Билдуем стратегию, ставим точки останова. Запускаем WLD, затем в студии выбираем в меню Debug — Attach to Proces, находим процесс wealthlabpro.exe и аттачимся к нему, в WLD жмем File — Open Strategy, ваша стратегия должна быть в корне, со специальной иконкой:

Если график открыт, то стратегия сработает при нажатии кнопки ОК, если нет — то при открытии графика:

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

Imports System
 Imports EnvDTE
 Imports EnvDTE80
 Imports EnvDTE90
 Imports EnvDTE90a
 Imports EnvDTE100
 Imports System.Diagnostics

 ' 1. Tools > Macros > Macro IDE
 ' 2. Right Click MyMacros > Add > Add Module
 ' 3. Paste in the code below:
 ' 4. Rename the Macro file DebuggingMacros
 ' Enable the debug toolbar
 ' Click the dropdown on the far right and click «Add or Remove buttons» > click «Customize»
 ' Click «Add Command»
 ' Select Macro on the left panel
 ' Find the macro in the list on the right
 ' Click «ok»
 ' Click «Modify Selection» and rename the button
 ' * repeat for nunit macro

 Public Module DebuggingMacros
     Public Sub AttachToWealthlab()
         Dim WLDAgent As String = «WealthLabPro.exe»
         If Not AttachToProcess(WLDAgent) Then
             System.Windows.Forms.MessageBox.Show(«Ca
 n't find WLD-agent process»)
         End If
     End Sub

     Public Function AttachToProcess(ByVal ProcessName As String) As Boolean
         Dim Processes As EnvDTE.Processes = DTE.Debugger.LocalProcesses
         Dim Process As EnvDTE.Process
         Dim ProcessFound As Boolean = False
         For Each Process In Processes
             If (Process.Name.Substring(Process.Name.LastIndexOf("\") + 1) = ProcessName) Then
                 Process.Attach()
                 ProcessFound = True
             End If
         Next
         AttachToProcess = ProcessFound
     End Function
 End Module

:[**:::right Автор статьи: AnCh

Hunting high and low

2012-04-01T13:29:42Z

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

Данные фьючерс РТС за 10-11 год (всего 477 точек), время в минутах (начиная с 10:00) дневного хая и лоя. (взаимная плотность, по x — время лоя, по y — время хая)

Собственно, что мы видим: есть два типа дней. У одних наиболее вероятный хай в районе 11 часов, а лой - в 500 минут от 10:00 (то есть 18:20). Второй тип: наиболее вероятный лой в районе 11 часов, а хай в ~470 минут от 10:00 (то есть 17:50-18:00). Попытки войти со среднесрочным горизонтом и коротким стопом в другие промежутки времени резко увеличивает вероятность, что вы поймаете стоп.

То же самое, но с разбивкой по дням недели:

Понедельник, Вторник

Среда, Четверг

Пятница

Неэффективные рынки. Теория Доу.

2012-04-01T13:29:44Z

Если немного «перепеть» классика, то тренд характеризуется тем, что каждый лоу выше/ниже предыдущего при аптренде/доунтренде. Попытаемся проверить, насколько эти представления актуальны. Для этого возьмем дневки Ри за 2010-2011 год и посчитаем разницу между лоу текущего дня и предыдущего, то есть LowDelta = Low[Day] — Low[Day — 1]. Нас будет интересовать, насколько значения этого ряда автоскоррелированы; то есть при аптренде, если верить теории Доу, положительные значения LowDelta должны следовать за положительными, а отрицательные — за отрицательными. Соответственно, получим числовой ряд этих LowDelta, который выглядящий следующим образом:

На первый взгляд, это — просто шум, но мы немного углубимся в его анализ. Чтобы как-то выразить соотношения по теории Доу, о которых сказано выше, математически, введем второй фактор — значение LowDelta за предыдущий день. Обозначим его LagLowDelta = Lag(LowDelta, 1) = Low[Day — 1] — Low[Day — 2]. Теперь нарисуем пары значений (LowDelta по X, LagLowDelta по Y):

Что мы здесь видим:

Плотность смещена в положительный квадрат (то есть LowDelta + и LagLowDelta +). То есть дней небольшого, но неотвратимого роста (когда лоу росли друг за другом), значительно больше.
В отрицательном квадрате больше выбросов быстрого падения. Теперь самый интересный вопрос, ради чего все это и затевалось — можно ли, смотря на приращения лоу, судить о тренде?

Считаем: Корреляция (LowDelta, LagLowDelta) = 0.21 = 21%, но она может завышать степень зависимости из-за выбросов. Поэтому посчитаем еще ранковую корреляцию Кендалла (она устойчива к любым выбросам) = 0.11 = 11%. Получилось значение в два раза меньше, но все равно статистически значимое.

Таким образом, мы приходим к выводу, что несмотря на свою 100-летнюю историю, пусть и достаточно маргинально (11% статистического перевеса не так много для дневных данных), Теория Доу продолжает работать.

Curve fitter-ы из Сан-Франциского федерального резервного банка

2012-04-01T20:26:25Z

В чем суть — два товарища из Сан-Франциского ФЕДа (Zheng Liu — a research advisor in the Economic Research Department of the Federal Reserve Bank of San Francisco и Mark M. Spiegel — a vice president in the Economic Research Department of the Federal Reserve Bank of San Francisco), решили провести исследование на тему того, как влияет отношение стареющего населения на P/E. Конкретно в качестве коэффициента старения они взяли логарифм отношения группы 40–49 лет к 60–69 далее M/O.

Оригинальная статья авторов Zheng Liu и Mark M. Spiegel размещена здесь.

Перевод статьи от slon.ru размещен здесь.

Ниже представлена оригинальная картинка из их расчета. Красным — PE, синим — этот коэффициент; слева — исторические данные, справа — предсказание модели.

Теперь они нам утверждают:

«Statistical analysis confirms this correlation. In our model, we obtain a statistically and economically significant estimate of the relationship between the P/E and M/O ratios. We estimate that the M/O ratio explains about 61% of the movements in the P/E ratio during the sample period. In other words, the M/O ratio predicts long-run trends in the P/E ratio well. »

«Статистический анализ подтвердил эти корреляции. В нашей модели мы получили статистические и экономически значимые оценки взаимосвязи между P/E и M/O(коэффициент старения). Мы оценили, что M/O отношения ОБЪЯСНЯЕТ БОЛЕЕ 61% ДВИЖЕНИЯ В P/E за заданныq период. Другими словами, M/O соотношение предсказывает долгосрочные тренды в P/E.» Собственно, первая мысль, которая возникла и в дальнейшем нашла подтверждение — они опять прогуляли в институте курсы по эконометрике и посчитали корреляцию двух процессов. Чтобы подтвердить гипотезу, пришлось скачать их данные и воспроизвести коэффициенты (та же самая картинка что у них, с кружочками — P/E, без M/O):

Теперь, добравшись до данных, считаем статистически корректно ранковую корреляцию приращений между двумя процессами. Получаем 0.15 (15%) при уровне статистической значимости 90% (то есть вероятность, что данная взаимосвязь получилась чисто случайно составляет ~10%, но это нормально, учитывая малый размер выборки). Прямой тест на коинтеграцию неприменим, так как процессы не unit root (то есть не интегралы белого шума), хотя и близки к нему. Но можно построить линейной регрессией спред, а дальше проверить, насколько статистически значима ECM (error-correction model) репрезентация. Результат получается схожий: значимость вклада спреда в приращения P/E выходит за границы статистической значимости (70%-ая вероятность того, что результат получен чисто случайно).

На рисунке ниже по горизонтали изображены приращения P/E, по вертикали — приращения M/O.

В общем, не верьте глазам своим. Несмотря на то, что кажется будто взаимосвязь между ними значительная, если посчитать ее статистически корректно она будет в районе 15% при не высоком уровне статистической значимости. А товарищам из FRBSF должно быть стыдно за то, что они внесли очередной вклад в поток псевдо-экономического шлака, от которого и так уже некуда деваться.

Данные и скрипты Вы можете скачать здесь.

ЛЧИ, данные

2012-04-01T20:26:28Z

С 2003 года проводится ежегодный всероссийский чемпионат по биржевой торговле – конкурс "Лучший частный инвестор". Многим трейдерам интересна статистическая составляющая этого конкурса, а именно анализ работы его участников и агрегированные данные. В данной статье показан способ получения статистики по ЛЧИ на примере данных 2011 года с использованием Python.

Скрипты на Питоне для выкачивания данных из статистики ЛЧИ и пост процессинга, а также данные по всем участникам за ЛЧИ 2011 скачать здесь.

Как использовать?

Скачать и установить сборку питона, если он не установлен (ссылка 1 и ссылка 2).
Набрать в командной строке команду "python". Должна появиться консоль питона (если этого не произошло, необходимо прописать в PATH путь к интерпретатору).
Скрипт download.py скачивает данные для заданного года и участника. Пример: python download.py 2011 dr-mart
Скрипт agregate.py агрегирует скаченные данные (т.е. раскладывает по инструментам, фиксит вечернюю сессию в хронологическом порядке, немного склеивает сделки и считает балансовую позицию). Пример: python agregate.py 2011 dr-mart
В результате должно получиться (dr-mart_RIZ1.csv):

code,direction,price,amount,time,date,balance 

RIZ1,1,122185.0,83,194936,20111005,83
RIZ1,-1,122220.0,-83,194956,20111005,0
RIZ1,-1,125610.0,-30,155054,20111006,-30
RIZ1,1,125965.0,6,174509,20111006,-24
RIZ1,1,125965.0,14,174510,20111006,-10
RIZ1,1,125965.0,1,174511,20111006,-9
RIZ1,1,126110.0,30,174515,20111006,21
RIZ1,1,126100.0,9,174616,20111006,30
RIZ1,1,125965.0,9,174645,20111006,39
RIZ1,-1,125100.0,-30,175144,20111006,9
RIZ1,1,125760.0,21,175858,20111006,30
RIZ1,1,126490.0,30,181004,20111006,60
RIZ1,-1,129025.0,-60,221820,20111006,0
RIZ1,-1,129780.0,-15,125659,20111007,-15
RIZ1,1,130630.0,15,160719,20111007,0
RIZ1,-1,131515.0,-15,175620,20111007,-15
RIZ1,-1,129180.0,-10,203153,20111007,-25
RIZ1,1,130750.0,25,232610,20111007,0

В аттаче — агрегированные текущие данные за 2011 для всех участников.

В корне архива lchi/VisualizeStrategy.wld расположена стратегия для WealtLab 5, которая визуализирует агрегированные данные.

Порядок действий:

Экспортировать данные по инструменту в data sets за период ЛЧИ (например, через Ascii Files — данные от финама размещены в папке lchi/rts_m1_lchi)
Создать новую пустую стратегию File → New → New Strategy From Code. В открывшуюся новую стратегию необходимо скопировать и заменить код из VisualizeStrategy.wld
Единственный параметр стратегии — это filePath; он идет первой строкой в методе Execute. В него необходимо прописать полный путь до файла, содержащего агрегированные с ЛЧИ данные по инструменту. Например, если распаковать архив lchi.rar в каталог c:/project, после чего мы хотим посмотреть торговлю dr-mart на ri, получаем следующее: string filePath = «c:/project/lchi/data/2011/agregate/dr-mart_RIZ1.csv». Вместо dr_mart_RIZ1.csv может быть любой другой файл из каталога agregate. Все слэши в пути должны быть обратными, как в примере! В результате получим такую картинку (за 16.11.2011 dr-mart):

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

Каким стереотипам о фондовом рынке стоит верить?

2012-04-25T22:36:33Z

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

**:::center Закономерность 1. Самая надежная и успешная стратегия поведения на рынке – стратегия «купил и держи» («bye and hold»)

Существует мнение о постоянном росте рынка. В доказательство обычно приводят пример индекса Доу-Джонса, выросшего за 20 век примерно в 1000 раз.

Следовательно, чтобы успешно работать на бирже, нужно накупить акций и ждать; самое сложное – перетерпеть возможные коррекции рынка. Действительно, фондовый рынок обычно достаточно длительное время находится в фазах интенсивного роста, и чем дольше эта фаза длится, тем крепче укореняется мысль о стратегии «купил и держи», и начинает казаться, что это самый удобный и простой способ обогащения. Однако опыт показывает, что следование этой стратегии всегда заканчивается жестокой расплатой. Периодичность таких событий обычно составляет 15-20 лет – именно столько составляет срок инвестиционной памяти участников рынка. Самый сокрушительный крах был в 1929-м году, когда биржевики выбрасывались из окон гостиниц Нью-Йорка. Самый недавний – мировой кризис 2008 года. И не всегда рынок восстанавливается быстро, как, например, после краха 1987 года. Бывают и длительные рецессии по 5-10 и более лет. Восстановление прежних позиций после краха 1929 года продолжалось около 20 лет, еще примерно столько же, в 60-80-е годы, рынок простоял на месте. В качестве еще одного примера можно привести Индекс Токийской фондовой биржи, движения которого также нестабильны и при этом динамика отрицательна.

Отметим, что и рост Индекса Доу-Джонса на три порядка за 100 лет на самом деле не такой уж впечатляющий: если усреднить весь рост с 1933 года (дно краха 1929 года) по сегодняшний день и пересчитать в годовые приросты – получится рост всего 8 % годовых.

**:::center Закономерность 2. В летние месяцы наблюдается снижение активности фондового рынка

С приближением лета в СМИ все чаще упоминается «летнее затишье». Об этом пишут аналитики и говорят комментаторы на РБК. Согласно этим сообщениям получается, что у фондового рынка тоже есть своеобразный период отпусков. На самом деле, для того, чтобы доказать, что нет такого понятия как «отпуск рынка», можно даже не использовать сложные алгоритмы вычислений. На примере изменений индекса РТС с 2000 по 2011 год была применена простая методика, которая позволяет определить удельный вес диапазона, пришедшегося на период отпусков с июня по август по отношению к диапазону всего года.

Исходя из данных таблицы, делаем следующий вывод: в среднем почти половина годового диапазона (49%) приходится на 3 летних месяца. Это значит, что лето – самый динамичный период в году.

**:::center Закономерность 3. Пятница – день фиксации прибыли, рынок в пятницу падает

К такому выводу пришли некоторые трейдеры и аналитики. Можно рассчитать, действительно ли для российского рынка характерно снижение котировок по пятницам. Рассчитаем, сколько было понедельников за последние 10 лет, когда торги закрывались в плюс, и сколько было понедельников, которые закрывались в минус; аналогично посмотреть статистику для каждого дня недели, для чего используем котировки индекса РТС с 2000 года по 2011 год.

В итоге приходим к следующему выводу: самым падающим днем является среда, именно в среду котировки росли всего лишь в 47% случаев, самыми растущими были понедельники и четверги. Цены повышались в эти дни соответственно в 56,8% и 55,4% случаев. Как видно, пятницу ни в коем случае нельзя назвать днем, когда надо открывать короткие позиции, только потому, что большинство будет фиксировать прибыль, иначе бы в 54,3% случаев рынок бы не закрывался в эти дни в плюс.

Статистические модели трендов. Смещение среднего.

2012-04-03T14:11:29Z

Попросили объяснить без специальных терминов, что такое персистентность и как она связана с трендовостью рынка. Совсем без терминов вряд ли получится, но если их минимизировать, то достаточно одного понятия — плотность вероятности.

Плотность вероятности — это функция, интеграл интервала которой дает нам вероятность попадания в этот интервал. Или, в простейшем случае, если мы рассматриваем ее эмпирическую оценку в виде гистограммы распределения, это будет просто частота попадания в набор фиксированных интервалов. Для примера рассмотрим гистограмму нормального распределения.

Собственно, что мы видим — это разбиение на набор фиксированных интервалов, затем подсчет попадания каждого значения в тот или иной интервал, который дает частоту. Если мы хотим посчитать частоту попадания в бОльший интервал (например от 0 до 2), то нам необходимо сложить(проинтегрировать) частоту попадания во все маленькие интервалы внутри этого отрезка [0, 2]. Таким образом плотность вероятности дает возможность, зная интервал, получить вероятность попадания в него. Или, если рассматривать на более «интуитивном» уровне, — показывает, какие значения выпадают более часто, а какие менее. В приведенном примере наиболее часто выпадают значения вокруг нуля распределения, а затем оно постепенно спадает.

Если мы рассмотрим распределение как набор значений, расположенных во времени (привычные для трейдинга представления в виде графиков числовых рядов), то получим для все того же нормального (гауссового) распределения следующую картинку:

Как и ожидалось из гистограммы распределения, 95% значений находятся внутри интервала от -2 до +2 с центром в 0.

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

Таким образом, мы подходим к первой простейшей модели тренда. Рассмотрим такое распределение приращений:

На глаз оно практически не отличается от предыдущего, но среднее (центр) значение сдвинуто на +0.1. Теперь просуммируем значения распределений для первого случая с нулевым и положительным (+0.1) смещением среднего. Так мы получим два графика случайных блужданий.

Первый график (без смещения в мат. ожидании приращений):

И второй график (с «ничтожным»,ели различимым на графике распределения приращений, смещением +0.1):

Разница разительная, но на первом графике заработать не возможно, а на втором — вполне.

В данном случае мы рассматриваем зависимость (смещение в мат. ожидании), которая не изменяется во времени, то есть стационарна, и равняется 0 для всего графика, или +0.1 — другого. Теперь представим, что эти значения сами изменяются во времени и представляют, например, кусочно-постоянную функцию, т.е. набор констант, из которого мы выбираем значение, действующее на каком-то интервале. Соответственно, если это значение положительное, возникает «растущий кусок тренда», если отрицательное — «падающий». А сам график «сшит» из таких интервалов с постоянными значениями. Таким образом мы получим приближенную к реальности простейшую динамическую модель тренда, у которой стационарное среднее приращений равняется 0, но при этом существуют интервалы, на которых оно отклоняется от 0 как в положительную, так и отрицательную сторону. При этом в среднем количество таких участков «уравновешивается», и мы получаем среднее всех приращений близким к 0.

Или если мы будем рассматривать среднее как функцию времени, то для кусочно-постоянной модели получим следующую картинку:

Или ввиде формулы: P_i+1 = P_i + A_k + N(0, 1) , где A_k — это значение среднего на данном временном интервале (t_k, t_k+1), N(0, 1) — стандартизированное нормальное распределение, Pi — это получившийся стохастический процесс.

Для примера рассмотрим реализацию такого стохастического процесса, при t_k = (0, 100, 200, 400, 450, 600, 650) и A_k = (+0.1, -0.1, +0.05, +0.15, -0.2, -0.05), что примерно соответствует представленному выше графику зависимости от времени.

Первая реализация:

Вторая реализация:

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

В следующей статье мы поговорим о еще одной модели тренда, которая связана с персистентностью. Точнее, мы будем понимать под персистентностью авто-регрессивность числового ряда.