Скачать MetaTrader 5

Учёт ордеров в большой программе

1 июня 2006, 10:28
Сергей Ковалев
13
4 750


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

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

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

Попробуем разобраться как лучше поставить учёт ордеров в большой программе.


1. Характеристика среды и общие рассуждения.

Остановимся кратко на характеристиках среды, в которой будет работать наша программа.

1. Прежде всего, конечно, мы хотим знать (то есть предполагается, что данные будут востребованы программой) сколько и каких ордеров у нас имеется. Причем недостаточно просто сказать, что у нас есть, скажем, 3 ордера Sell и 4 ордера Buy. Скорее всего сколько-нибудь интеллектуальная торговая система содержит алгоритм управления характеристиками ордеров - положением StopLoss и TakeProfit, а для отложенных ордеров ещё и положением самого ордера - OpenPrice. Кроме того, нам понадобится знание того, сколько стоит каждый ордер, какой у него срок жизни, какой программой он создан.

2. Тики. Любая информация имеет смысл, если она рассматривается вовремя. Любой эксперт имеет дело с котировками цены, постоянно поступающими в терминал. Очевидно, что ситуация с ордерами может поменяться на любом изменении цены, то есть вести "переучёт" необходимо на каждом тике.

3. К общим характеристикам можно отнести валютный инструмент, в окне которого установлен эксперт.

Учитывая эти простые сведения мы можем определить общие принципы построения программы, содержащей учёт ордеров.

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

Во-вторых, сведения, накопленные функцией Terminal(), должны быть доступны другим функциям, поэтому переменные, несущие полезную иформацию об ордерах, необходимо объявить на глобальном уровне (не путать с глобальными переменными GlobalVariable).

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


2. Структура программы.

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

// My_expert.mq4
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
#include ...
#include <Peremen.mq4>          // Описание переменных эксперта.   
#include <Terminal.mq4>         // Присоединение функции Terminal.
#include <Sobytiya.mq4>         // Присоединение функции Sobytiya.
#include ...
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
//
// 
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
int init()  
   {
   ...                                       // Код функции init()
   return;
   } 
//=================================================================
int start() 
   {
   Terminal();                   // Эта функция стоит первой в ..
                                 // ..последовательности функций
   ...                           // Последующий код функции start()
   Sobytiya();                   // Функция обработки событий
   ...                           // Последующий код функции start()
   return;                                                                 
   }
//=================================================================
int deinit() 
   {   
   ...                                    // Код функции deinit()
   return;
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж

Файл Peremen.mq4, описывающий переменные, должен содержать описание массивов, несущих сведения об ордерах.

//  Peremen.mq4
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
//=================================================================
int
...
//=================================================================
double
...
Mas_Ord_Tek[31][8], Mas_Ord_Old[31][8], 
// Массив ордеров текущий и старый
// 1й индекс = порядковый номер ордера в этом массиве
// [][0] не определяется
// [][1] курс откр. ордера   (абсолютное знач. курса)
// [][2] StopLoss ордера     (абсолютное знач. курса)
// [][3] TakeProfit ордера   (абсолютное знач. курса)
// [][4] номер ордера        
// [][5] колич. лотов ордера (абсолютное знач. курса)
// [][6] тип ордера 1=B,2=S,3=BL,4=SL,5=BS,6=SS
// [][7] Магическое число ордера
...
//=================================================================
string 
...
//=================================================================
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж

При определении глобальных переменных в небольших программах их обычно прописывают непосредственно перед первой встречающейся функцией. В средних и больших программах имеет смысл собрать все глобальные переменные в один файл и присоединить его к эксперту посредством инструкции #include. С точки зрения работоспособности кода разница в способах не имеет значения, но с точки зрения удобства пользования присоединение файла предпочтительно. В данном примере файл Peremen.mq4 присоединён в эксперт именно таким способом.


3. Массивы.

В файле Peremen.mq4 в качестве глобальных переменных определено два массива:

Mas_Ord_Tek[31][8] - массив ордеров текущий;

Mas_Ord_Old[31][8] - массив ордеров старый.

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

Почему используется двумерный массив? Потому, что мы будем вести учёт одновременно нескольких ордеров, причём о каждом из них будем хранить информацию по нескольким характеристикам. Первый индекс - порядковый номер ордера в массиве, второй - ордерная характеристика по заданному критерию. В данном примере первый индекс допускает присутствие в терминале не более 30 ордеров. Вы можете по своему усмотрению произвольно изменить эту цифру, предполагая учёт одновременно присутствующих в терминале, например, 50-и или 100 ордеров. Разумеется, это имеет смысл делать только в том случае, если Ваша торговая система предполагает работать с таким количеством ордеров. В обычной ситуации используются 1 - 2 ордера, в более редких случаях - 4. 30 по моим представлениям - это уже очень много.

Почему в индексных скобках массивов указано значение 31 и 8, а не 30 и 7? Дело в том, что массивы в MQL4 начинают отсчёт индексов с нуля. Использование нулевых ячеек для рядовых элементов далеко не всегда оправдано. На мой взгляд логично поставить в соответствие порядковый номер ордера порядковому номеру элемента массива, например, третий по счёту ордер должен находиться в строке, индекс которой 3. Фактически по количественному счёту это будет четвёртая строка, но индекс у неё 3, так как у самой первой строки - индекс 0.

Рассмотрим таблицу, в которой наглядно представлено внутреннее наполнение массивов. Предположим, что имеется всего 3 ордера: Buy, Sell и BuyStop разного качества.


Содержательная информация об ордерах располагается в ячейках массива с номерами от [1][1] до [7][30]. Кроме того, в ячейку с индексом [0][0] мы поместим общее количество ордеров, содержащихся в массиве. В данном случае - 3. В дальнейших расчётах эта цифра понадобится для организации циклов, в которых будет производиться анализ текущего состояния.

Таким образом мы можем хранить информацию о 30-и ордерах, каждый из которых отмечен по 7-ми характеристикам.

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

Более удобным вариантом решения является использование одного большого массива (одного старого и одного нового) для учёта всех ордеров. Такой выбор лучше, потому что при обработке этого массива в дальнейшем коде не придётся искать названия массивов ордеров валютных инструментов, а достаточно организовать перебор в цикле формальной численной переменной по одному из индексов массива.

Массив, содержащий сведения обо всех ордерах, может быть организован так:


Информация об ордерах по каждому валютному инструменту хранится в одной индексной плоскости подобно рассмотренному ранее примеру. Отличие состоит в том, что в данном случае таких плоскостей несколько ( на рисунке представлено 3 - жёлтая, розовая и зелёная). Общее их количество равно количеству валютных пар, с которыми мы предполагаем работать плюс ещё одна, нулевая. В этой индексной плоскости (серого цвета), в ячейке с индексом [0][0][0] хранится единственное значение - общее количество ордеров.

Размерность массива, например для 25 валютных инструментов, по первому индексу будет равна 26. В этом случае файл Peremen.mq4, описывающий массивы, будет выглядеть так:

//  Peremen.mq4
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
//============================================================================
int
...
//============================================================================
double
...
Mas_Ord_Tek[26][31][8], Mas_Ord_Old[26][31][8], // Массив ордеров текущий и старый
                                 // 1й индекс = порядковый номер валютного инструмента
                                 // 2й индекс = порядковый номер ордера ..
                                 // .. на плоскости валютного инструмента
                                 // [][][0] не определяется
                                 // [][][1] курс откр. ордера   (абсолютное знач. курса)
                                 // [][][2] StopLoss ордера     (абсолютное знач. курса)
                                 // [][][3] TakeProfit ордера   (абсолютное знач. курса)
                                 // [][][4] номер ордера        
                                 // [][][5] колич. лотов ордера (абсолютное знач. курса)
                                 // [][][6] тип ордера 1=B,2=S,3=BL,4=SL,5=BS,6=SS
                                 // [][][7] Магическое число ордера
//=================================================================
string 
      Instrument[26];          // Массив названий валютных инструментов
...
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
//
//
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
int Predopred()
   {
//=============================================== Предопределения =
   Instrument[1] = "EURUSD";
   Instrument[2] = "GBPUSD";
   ...
   Instrument[25]= "AUDCAD";
//==================================================================
   return();
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж

В нижней части блока открытия переменных этого файла открыт массив Instrument[26].

В большой программе как правило имеется множество переменных, значения которых по ходу выполнения программы не меняются. В данном случае к ним относятся элементы массива Instrument[]. Для удобства программирования такие переменные имеет смысл собрать в одну функцию, можно также оформить её в виде отдельного файла, присоединяемого к программе с помощью #include.

В данном примере показано предопределение элементов массива Instrument[] в функции Predopred() содержащейся в том же файле Peremen.mq4. Эту функцию достаточно запустить на выполнение всего один раз, поэтому имеет смысл включить её в программу в специальной функции init():

int init()  
   {
   Predopred();            // Предопределение некоторых перем
   return;
   }

Таким образом некоторые целые числа, в данном случае содержащиеся в значениях индексов массива Instrument[], поставлены в соответствие валютным инструментам.


4. Функция учёта ордеров.

Теперь рассмотрим из чего состоит функция Terminal() для учёта одеров по одному валютному инструменту. Эта функция также организуется в виде отдельного файла с одноимённым названием Terminal.mq4 и присоединяется к эксперту с помощью инструкции #include.

// Terminal.mq4
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
int Terminal()
   {
//============================================== Предопределения ==
   ArrayCopy(Mas_Ord_Old, Mas_Ord_Tek);
// Сохраняем предыдущую историю
   int Kol=0;                         // Обнуление счётчика ордеров
   ArrayInitialize(Mas_Ord_Tek,0);    // Обнуление массива
//=============================================== Анализ ордеров ==
   for (int i=0; i<OrdersTotal(); i++)// По всем ордерам терминала
     {
      if((OrderSelect(i, SELECT_BY_POS)==true) && 
          (OrderSymbol()==Symbol()))
                                //Если есть следующ и наша вал.пара
       {                                                                     
        Kol++;                  // Считаем общее количество ордеров
//-------------------------- Формирование нового массива ордеров --
        Mas_Ord_Tek[Kol][1] = NormalizeDouble(OrderOpenPrice(),
                                              Digits); 
// Курс открытия ордеров
        Mas_Ord_Tek[Kol][2] = NormalizeDouble(OrderStopLoss(),
                                              Digits); 
// Курс SL 
        Mas_Ord_Tek[Kol][3] = NormalizeDouble(OrderTakeProfit(),
                                              Digits); 
// Курс ТР 
        Mas_Ord_Tek[Kol][4] = OrderTicket();     // Номер ордера
        Mas_Ord_Tek[Kol][5] = OrderLots();       // Количество лотов
        Mas_Ord_Tek[Kol][6] = OrderType();       // Тип ордера
        Mas_Ord_Tek[Kol][7] = OrderMagicNumber();// Магическое число 
//------------------------------------------------------------------
       }
     }
   Mas_Ord_Tek[0][0] = Kol; // Сохраняем в нулевую ячеечку
//==================================================================
   return();
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж

Первое, что необходимо сделать с момента, когда система передала управление функции Terminal() - это сохранить предыдущее состояние ордеров. Оно содержится в массиве Mas_Ord_Tek[][], но на текущий момент не является актуальным, так как отражает состояние ордеров, сложившееся на предыдущем тике. Текущее состояние на начальный момент ещё не известно.

В строке

   ArrayCopy(Mas_Ord_Old, Mas_Ord_Tek);
// Сохраняем предыдущую историю

последнее известное состояние ордеров передаётся в массив Mas_Ord_Old[][].

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

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

   for (int i=0; i<OrdersTotal(); i++)
// По всем ордерам терминала

Обратите внимание, OrdersTotal() определяет количество ордеров, а исчисление порядковых номеров ордеров в терминале начинается с 0. Поэтому в строке цикла используется знак "<" и изменение внутренней переменной цикла начинается с нуля: i=0.

В последующем коде выделяется ордер, принадлежащий валютному инструменту, в окно которого прикреплён эксперт. С помощью функций, определяющих различные характеристики ордера, полученная информация заносится в соответствующие элементы массива Mas_Ord_Tek[][].

//------------------------- Формирование нового массива ордеров --
       Mas_Ord_Tek[Kol][1] = NormalizeDouble(OrderOpenPrice(),
                                             Digits); 
// Курс открытия ордера
       Mas_Ord_Tek[Kol][2] = NormalizeDouble(OrderStopLoss(),
                                             Digits); 
// Курс SL
       Mas_Ord_Tek[Kol][3] = NormalizeDouble(OrderTakeProfit(),
                                             Digits); 
// Курс ТР
       Mas_Ord_Tek[Kol][4] = OrderTicket(); // Номер ордера
       Mas_Ord_Tek[Kol][5] = OrderLots();   // Количество лотов
       Mas_Ord_Tek[Kol][6] = OrderType();   // Тип ордера
       Mas_Ord_Tek[Kol][7] = OrderMagicNumber();// Магическое число 
//-----------------------------------------------------------------

Попутно наполняемый счётчик по окончании цикла передаёт своё значение нулевому элементу массива.

   Mas_Ord_Tek[0][0] = Kol;    // Сохраняем в нулевую ячеечку

Для случая одновременной торговли по нескольким валютным инструментам функция Tеrminal() может быть составлена так:

// Terminal.mq4
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
int Terminal()
   {
//============================================== Предопределения =
   ArrayCopy(Mas_Ord_Old, Mas_Ord_Tek);
// Сохраняем предыдущую историю
   ArrayInitialize(Mas_Ord_Tek,0); 
// Обнуление массива текущих орд.
//=============================================== Анализ ордеров =
   for (int i=0; i<OrdersTotal(); i++)// По всем ордерам терминала
      {
      if(OrderSelect(i, SELECT_BY_POS)==true)
// Если ещё есть живой ордер
         {
//-------------------- Определение индекса валютного инструмента -
         string Symb=OrderSymbol();
// Выясним валюту текущего ордера
         for (int ind=1; ind<=25; ind++)
// Поиск по массиву вал. инстр.
            {
            if (Symb==Instrument[ind])
// Индекс определён, поиск закончен
               break;                                   
// Выходим из цикла по ind
            }
//---------------------- Формирование нового массива ордеров ----
         Mas_Ord_Tek[0][0][0]++;
// Считаем общее количество ордеров
         Mas_Ord_Tek[ind][0][0]++;
// Считаем колич.орд. по валют.паре
         int k=Mas_Ord_Tek[ind][0][0]; // Формальная переменная
         
         Mas_Ord_Tek[ind][k][1] = NormalizeDouble(OrderOpenPrice(),
                                                  Digits); 
// Курс откр. ордеров
         Mas_Ord_Tek[ind][k][2] = NormalizeDouble(OrderStopLoss(),
                                                  Digits); 
// Курс SL
         Mas_Ord_Tek[ind][k][3] = NormalizeDouble(OrderTakeProfit(),
                                                  Digits); 
// Курс ТР
         Mas_Ord_Tek[ind][k][4] = OrderTicket(); // Номер ордера
         Mas_Ord_Tek[ind][k][5] = OrderLots();   // Колич. лотов
         Mas_Ord_Tek[ind][k][6] = OrderType();   // Тип ордера
         Mas_Ord_Tek[ind][k][7] = OrderMagicNumber();
// Магическое число 
         
//-----------------------------------------------------------------
         }
      }
//=================================================================
   return();
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж

Отличием в алгоритме учёта ордеров для нескольких валютных инструментов от алгоритма, составленного для одной валютной пары, является небольшой блок для определения индекса валютного инструмента.

//----------------- Определение индекса валютного инструмента ----
         string Symb=OrderSymbol();
// Выясним валюту текущего ордера
         for (int ind=1; ind<=25; ind++)
// Поиск по массиву вал. инстр.
            {
            if (Symb==Instrument[ind])
// Индекс определён, поиск закончен
               break;                 // Выходим из цикла по ind
            }

В последующих строках функции Terminal() найденное значение индекса валютного инструмента ind определяет индекс плоскости массива, содержащего сведения об ордерах по соответствующему валютному инструменту.

В представленных примерах реализации функции Terminal() при вычислении некоторых переменных используется нормализация:

Mas_Ord_Tek[ind][k][1] = NormalizeDouble(OrderOpenPrice(),Digits); 
// Курс откр. ордера
Mas_Ord_Tek[ind][k][2] = NormalizeDouble(OrderStopLoss(),Digits); 
// Курс SL
Mas_Ord_Tek[ind][k][3] = NormalizeDouble(OrderTakeProfit(),Digits); 
// Курс ТР

Необходимость этих вычислений состоит в том, чтобы в будущих расчётах использовать в операторах сравнения нормализованные значения переменных. При этом количество значащих цифр определяется на основе предопределённой переменной Digits.

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

5. Обработка событий.

Итак, новый тик случился и функция Tеrminal() отработала. Управление будет передано операторам, стоящим непосредственно после функции Terminal(). Заранее нельзя сказать в какой части специальной функции start() должна находиться та или иная пользовательская функция обработки событий - это зависит от идеи, закладываемой в торговую систему. В простом случае обработка по крайней мере некоторых событий может осуществляться сразу же.

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

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

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

В-третьих, аналогичная специфика возникает и при закрытии одного ордера за счёт другого, если эти ордера имеют разную стоимость. Фактически в этом случае повторяется ситуация частичного закрытия одного из ордеров.

Единственная возможность идентифицировать ордер - это анализировать такой его параметр, который не изменяется и не повторяется. Из всех возможностей, предоставляемых MQL4, мне удалось выявить единственный такой параметр - MagicNumber. Но даже и в этом случае программист не может рассчитывать на создание полного контроля ситуации. Дело в том, что MagicNumber не может быть изменён программно. С одной стороны в этом есть неоспоримое преимущество - мы можем быть уверены, что этот параметр не изменится пока существует ордер даже случайно. Но с другой стороны хотелось бы иметь некоторый настраиваемый параметр, доступ к которому программно разрешён. На текущий момент такой возможности нет, поэтому если некоторый ордер (один или несколько) открыты не нашей торговой системой, а другой программой или "с руки", то нет возможности как-то пометить такие ордера, чтобы иметь признак, отличающий их от "наших" и между собой.

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

Рассмотрим пример реализации функции Sobytiya(), заключённой в одноимённом файле Sobytiya.mq4. Отследим простое событие - удаление или закрытие ордера.

Мы выяснили уже, что номер ордера для этой цели годится не всегда, поэтому будем анализировать MagicNumber.

// Sobytiya.mq4   
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
int Sobytiya()
   {
//==================================== Поиск пропавших ордеров ====
   for (int oo=1;oo<=Mas_Ord_Old[0][0];oo++)     
// Возьмём номер ордера из старого массива
      {   
      int Sovpadenie=0;                          
// Для начала обнулим факт признака совпад.
      for (int i=1;i<=Mas_Ord_Tek[0][0];i++)     
// Поищем этот ордерок в текущем массиве 
         {
         if (Mas_Ord_Tek[i][7]==Mas_Ord_Old[oo][7]) 
// Если совпал MagicNumber ордера, то запомним, т.е пока жив
// и выходим из внутреннего цикла
            {
            Sovpadenie=1;                           
            break;                                
            }
         }      
      if (Sovpadenie==1) continue;  // Переходим к следующему старому
      Alert("Закрыт ордер ",Mas_Ord_Old[oo][4]); 
// Сообщим текстом на экран
      PlaySound( "Close_order.wav" );               
// И музычку.
      }
//=================================================================
   return();
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж

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

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

// Sobytiya_2.mq4   
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
int Sobytiya_2()
   {
//============================== Поиск ордеров, поменявших тип ====
   for(int oo=1;oo<=Mas_Ord_Old[0][0]; oo++)               
// Пройдёмся по старому массиву
      {
      for (int i=1;i<=Mas_Ord_Tek[0][0];i++)              
// Поищем ордер в текущ. массиве 
         {
         if (Mas_Ord_Tek[i][4] == Mas_Ord_Old[oo][4] &&    
// Если в старом был такой же ордер но другого типа, то:
             Mas_Ord_Tek[i][6] != Mas_Ord_Old[oo][6])      
            {                                                  // Отложенный стал явным
            Alert("Трансформировался ордер",Mas_Ord_Tek[i][4]);
// Сообщим текстом на экран
            PlaySound("Transform.wav" );                       
// И музычку
            }
         }
      }
//=================================================================
   return();
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж

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

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

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

   Mas_Ord_Tek[ind][k][1] = NormalizeDouble(OrderOpenPrice(),
                                            Digits+1); 
// Курс откр. орд

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

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

Последние комментарии | Перейти к обсуждению на форуме трейдеров (13)
Evgeniy Zykov
Evgeniy Zykov | 4 мар 2015 в 07:14

Добрый день. Использовал ваш код в советнике но никак не могу реализовать запись массива на диск и его чтение. Может подскажите что делаю не так?

//+------------------------------------------------------------------+
int init()
    {
      FilesOpen(); // Читаем Файл в массив -->-Massiv
      return(0);
     }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int deinit()  
  {
      FilesWrite(); //  //  Пишем массив Massiv --> в Файл        
 return(0);  
  }
//+------------------------------------------------------------------+
//........
//+------------------------------------------------------------------+
void FilesOpen()   // Читаем Файл в Massiv -->-- (резервное копирование)
  {
   int h=FileOpen("Massiv.bin",FILE_BIN|FILE_READ);
  if(h<1)
    {
     Print("Файл Massiv.bin не обнаружен, последняя ошибка ", GetLastError());
     return(false);
    }
   int s=FileReadInteger(h,LONG_VALUE);
   ArrayResize(Massiv,s);
   FileReadArray(h,Massiv,0,s);
   FileClose(h);   
   }  
//+------------------------------------------------------------------+
void FilesWrite()   //  Пишем  Massiv --> в Файл (резервное копирование)
  {
   int h=FileOpen("Massiv.bin",FILE_BIN|FILE_WRITE);
   FileWriteInteger(h,ArraySize(Massiv),LONG_VALUE);
   FileWriteArray(h,Massiv,0,ArraySize(Massiv));
   FileClose(h);
  }  
Dmitriy Falkov
Dmitriy Falkov | 13 янв 2016 в 19:13

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

Лично я использую следующую конструкцию сразу после обнуления переменных при инициализации start():

//---- Пересчет и ведение открытых ордеров   
for(int i=OrdersTotal()-1;i>=0;i--)
   if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)){
      if(OrderType()==OP_BUY && OrderSymbol()==_Symbol){//Есть открытый BUY
         if (условие закрытия ордера) {                 //если выполняется условие для закрытия, например, достигнут нужный уровень
            CloseOrder(OrderTicket());                  //вызываем функцию закрытия
            oBuy--;}                                    //раз ордер закрыт, то его из общего числа вычитаем
         oBuy++;}                                       //суммируем ордера нужного типа
      if(OrderType()==OP_SELL && OrderSymbol()==_Symbol){
         if (условие закрытия ордера) {
            CloseOrder(OrderTicket());
            oSell--;}
            }
         oSell++;}
}

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

Vasyl Nosal
Vasyl Nosal | 13 янв 2016 в 19:31
Dmitriy Falkov:

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

Лично я использую следующую конструкцию сразу после обнуления переменных при инициализации start():

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

так как все номера сместились бы для замещения закрытого

:))))))))))))))))) 

Dmitriy Falkov
Dmitriy Falkov | 26 янв 2016 в 13:53
Vasyl Nosal:

так как все номера сместились бы для замещения закрытого

:))))))))))))))))) 

И что тут смешного, есть какие-то конкретные аргументы? Или вы заглянули просто поржать?

Я просто представил простой вариант и объяснил, почему обратный перебор предпочтительней прямого. У вас есть ордера 1, 2, 3 и 4. Вы начинаете перебор с 1. Закрыли номер 1 и перешли в цикле к номеру 2. Но при закрытии ордера у вас стало 1, 2 и 3. При этом бывший 2 стал "1", а вы в цикле просматриваете номер 3, который и стал номером "2". Если таким циклом вы попробуете закрыть все ордера, то в итоге увидите, что закрыли только через один.

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

Maxim Kuznetsov
Maxim Kuznetsov | 26 янв 2016 в 15:00

в статье конечно просто объёмная вода ради публикации, но хочу обратить внимание автора

        Kol++;                  // Считаем общее количество ордеров
//-------------------------- Формирование нового массива ордеров --
        Mas_Ord_Tek[Kol][1] = NormalizeDouble(OrderOpenPrice(),
                                              Digits); 
// Курс открытия ордеров
        Mas_Ord_Tek[Kol][2] = NormalizeDouble(OrderStopLoss(),
                                              Digits); 

вот за такой стиль кода при (вдруг вам посчастливится) коллективной работе "убивают"

Переход на новые рельсы: пользовательские индикаторы в MQL5 Переход на новые рельсы: пользовательские индикаторы в MQL5

Я не буду перечислять все новые возможности и особенности нового терминала и языка. Их действительно много, и некоторые новинки вполне достойны освещения в отдельной статье. Вы не увидите здесь кода, написанного по принципам объектно-ориентированного программирования — это слишком серьезная тема для того, чтобы просто быть упомянутой в контексте как дополнительная вкусность для кодописателей. В этой статье остановимся подробней на индикаторах, их строении, отображении, видах, а также особенностях их написания по сравнению с MQL4.

Вот мы и получили долгожданные MetaTrader 5 и MQL5 Вот мы и получили долгожданные MetaTrader 5 и MQL5

Это очень краткий обзор MetaTrader 5. Я не могу описать все новшества системы за столь короткий период времени - тестирование стартовало 09-09-2009. Это символическая дата, и я уверен, что это будет счастливым числом. Всего несколько дней у меня на руках бета-версия терминала MetaTrader 5 и MQL5. Я не успел опробовать все, что в нем есть нового, но то, что есть, уже впечатляет.

Как построить и протестировать стратегию бинарных опционов в Тестере Стратегий MetaTrader 4 Как построить и протестировать стратегию бинарных опционов в Тестере Стратегий MetaTrader 4

Руководство по построению стратегии бинарных опционов и ее тестированию в Тестере Стратегий MetaTrader 4 с использованием утилиты Binary-Options-Strategy-Tester из Маркета на MQL5.com.

Портфельная торговля в MetaTrader 4 Портфельная торговля в MetaTrader 4

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