MetaTrader 5 / Примеры
English 中文 Español Deutsch 日本語 Português
preview
StringFormat(). Обзор, готовые примеры использования

StringFormat(). Обзор, готовые примеры использования

MetaTrader 5 — Примеры | 17 июля 2023, 13:00
985 0
Artyom Trishkin
Artyom Trishkin

Содержание


Введение

При выводе в журнал структурированной и отформатированной информации при помощи PrintFormat() мы просто форматируем данные в упорядоченный в соответствии с указанным форматом вид и выводим их в журнал терминала. Для последующего использования такая отформатированная информация уже не доступна. Для повторного её вывода нужно опять прибегать к форматированию при помощи PrintFormat(). Было бы хорошо иметь возможность повторного использования единожды отформатированных в нужный вид данных. И такая возможность есть — это функция StringFormat(). В отличие от своего "собрата" PrintFormat(), просто распечатывающего данные в журнал, эта функция возвращает отформатированную строку. А это позволяет использовать эту строку далее в программе — т.е. отформатированная в нужный вид информация не теряется. А это куда более удобно — можно сохранить форматированные строки в переменные или массив и брать их от-туда для повторного использования. Это намного гибче и удобнее.

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


StringFormat(). Краткий обзор

Функция StringFormat() форматирует полученные параметры и возвращает отформатированную строку. Правила форматирования строки точно такие же, как и у функции PrintFormat(). Эти правила были подробно рассмотрены в статье "Изучаем PrintFormat() и берем готовые к использованию примеры". Сначала передаётся строка с текстом и спецификаторами формата, а следом через запятую необходимые данные, которые должны быть на месте спецификаторов в строке. Каждому спецификатору должны соответствовать свои данные. В строгом порядке.

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


Форматирование строк

Для ознакомления с правилами форматирования строк можно прочитать раздел о всех спецификаторах в статье о PrintFormat(). Для уточнения работы спецификаторов, указывающих размер данных (h | l | ll | I32 | I64), можно воспользоваться таким скриптом, наглядно показывающим разницу между выводом данных, имеющих разные размеры:

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   long x = (long)0xFFFFFFFF * 1000;

   Print("\nDEC: ",  typename(x)," x=",x,"\n---------");
   Print("%hu: ",  StringFormat("%hu",x));
   Print("%u: ",   StringFormat("%u",x));
   Print("%I64u: ",StringFormat("%I64u",x));
   Print("%llu: ", StringFormat("%llu",x));
   Print("\nHEX: ",  typename(x)," x=",StringFormat("%llx",x),"\n---------");
   Print("%hx: ",  StringFormat("%hx",x));
   Print("%x: ",   StringFormat("%x",x));
   Print("%I64x: ",StringFormat("%I64x",x));
   Print("%llx: ", StringFormat("%llx",x));

  }

Результат

2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  DEC: long x=4294967295000
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  ---------
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %hu: 64536
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %u: 4294966296
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %I64u: 4294967295000
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %llu: 4294967295000
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  HEX: long x=3e7fffffc18
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  ---------
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %hx: fc18
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %x: fffffc18
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %I64x: 3e7fffffc18
2023.07.12 17:48:12.920 PrinFormat (EURUSD,H1)  %llx: 3e7fffffc18

Наверное, это единственный спецификатор, который был не в полной мере освещён в статье о PrintFormat().


Форматированный вывод свойств символа

Для целей данной статьи нам нужно будет на каждое свойство символа написать по две функции. Первая функция будет форматировать строку в нужный для печати вид, а вторая — распечатывать в журнал полученную первой функцией строку. Чтобы следовать тому же принципу форматирования строк, что был принят в статье о PrintFormat(), в каждую функцию тоже будем передавать отступ строки от левого края и ширину поля заголовка. Таким образом мы сохраним единое форматирование для вывода в журнал свойств аккаунта и свойств символа.

Для получения времени в миллисекундах создадим функцию, возвращающую строку со временем в формате Date Time.Msc на основе функции, рассмотренной в прошлой статье о PrintFormat():

//+------------------------------------------------------------------+
//| Принимает дату в мс, возвращает время в формате Date Time.Msc    |
//+------------------------------------------------------------------+
string TimeMSC(const long time_msc)
  {
   return StringFormat("%s.%.3hu",string((datetime)time_msc / 1000),time_msc % 1000);
   /* Пример вывода:
   2023.07.13 09:31:58.177
   */
  }

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

Итак, начнём по порядку: целочисленные, вещественные и строковые свойства символа. Функции будем писать в порядке следования свойств в разделе справки "Информация об инструменте".


Получение и вывод целочисленных свойств символа ENUM_SYMBOL_INFO_INTEGER

Задержка данных (SYMBOL_SUBSCRIPTION_DELAY)

Признак того, что данные по символу идут с задержкой. Свойство можно запрашивать только для символов, выбранных в MarketWatch (SYMBOL_SELECT = true). Для невыбранных символов будет сгенерирована ошибка ERR_MARKET_NOT_SELECTED (4302)

Возвращает строковое значение свойства с заголовком. Для форматируемой строки возможно указать отступ от левого края и ширину поля заголовка:

//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//} что данные по символу идут с задержкой                           |
//+------------------------------------------------------------------+
string SymbolSubscriptionDelay(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Создаём переменную для хранения текста ошибки
   //string error_str;
//--- Если символа symbol не существует - возвращаем текст ошибки
   if(!SymbolInfoInteger(symbol,SYMBOL_EXIST))
      return StringFormat("%s: Error. Symbol '%s' is not exist",__FUNCTION__,symbol);
//--- Если символ не выбран в окне MarketWatch - пробуем его выбрать
   if(!SymbolInfoInteger(symbol,SYMBOL_SELECT))
     {
      //--- Если не удалось выбрать символ в окне MarketWatch - возвращаем текст ошибки
      if(!SymbolSelect(symbol,true))
         return StringFormat("%s: Failed to select '%s' symbol in MarketWatch. Error %lu",__FUNCTION__,symbol,GetLastError());
     }
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Subscription Delay:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_SUBSCRIPTION_DELAY) ? "Yes" : "No");
   /* Пример вывода:
      Subscription Delay: No
   */
  }

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

Выводит в журнал значение, возвращаемое первой функцией:

//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что данные по символу идут с задержкой                           |
//+------------------------------------------------------------------+
void SymbolSubscriptionDelayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSubscriptionDelay(symbol,header_width,indent));
  }


Сектор экономики (SYMBOL_SECTOR)

Сектор экономики, к которому относится символ.

//+------------------------------------------------------------------+
//| Возвращает как строку сектор экономики,                          |
//| к которому относится символ                                      |
//+------------------------------------------------------------------+
string SymbolSector(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение сектора экономики
   ENUM_SYMBOL_SECTOR symbol_sector=(ENUM_SYMBOL_SECTOR)SymbolInfoInteger(symbol,SYMBOL_SECTOR);
//--- "Вырезаем" из строки, полученной из enum, только наименование сектора
   string sector=StringSubstr(EnumToString(symbol_sector),7);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(sector.Lower())
      sector.SetChar(0,ushort(sector.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(sector,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Sector:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,sector);
   /* Пример вывода:
      Sector: Currency
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал сектор экономики, к которому относится символ   |
//+------------------------------------------------------------------+
void SymbolSectorPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSector(symbol,header_width,indent));
  }


Вид промышленности (SYMBOL_INDUSTRY)

Вид промышленности или отрасль экономики, к которому относится символ.

//+------------------------------------------------------------------+
//| Возвращает как строку вид промышленности или отрасль экономики,  |
//| к которому относится символ                                      |
//+------------------------------------------------------------------+
string SymbolIndustry(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение вида промышленности
   ENUM_SYMBOL_INDUSTRY symbol_industry=(ENUM_SYMBOL_INDUSTRY)SymbolInfoInteger(symbol,SYMBOL_INDUSTRY);
//--- "Вырезаем" из строки, полученной из enum, только наименование вида промышленности
   string industry=StringSubstr(EnumToString(symbol_industry),9);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(industry.Lower())
      industry.SetChar(0,ushort(industry.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(industry,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Industry:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,industry);
   /* Пример вывода:
      Industry: Undefined
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал вид промышленности или отрасль экономики,       |
//| к которому относится символ                                      |
//+------------------------------------------------------------------+
void SymbolIndustryPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolIndustry(symbol,header_width,indent));
  }

Пользовательский символ (SYMBOL_CUSTOM)

Признак того, что символ является пользовательским, то есть искусственно созданным на основе других символов из Market Watch или/и внешних источников данных.

//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ является пользовательским                             |
//+------------------------------------------------------------------+
string SymbolCustom(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Custom symbol:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_CUSTOM) ? "Yes" : "No");
   /* Пример вывода:
   Custom symbol: No
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что символ является пользовательским                             |
//+------------------------------------------------------------------+
void SymbolCustomPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCustom(symbol,header_width,indent));
  }


Цвет фона в Market Watch (SYMBOL_BACKGROUND_COLOR)

Цвет фона, которым подсвечивается символ в Market Watch.

//+------------------------------------------------------------------+
//| Возвращает как строку цвет фона, которым подсвечивается          |
//| символ в Market Watch                                            |
//+------------------------------------------------------------------+
string SymbolBackgroundColor(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Background color:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем цвет фона символа в Market Watch
   color back_color=(color)SymbolInfoInteger(symbol,SYMBOL_BACKGROUND_COLOR);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
//--- Если для символа установлен цвет по умолчанию (0xFF000000), то возвращаем 'Default', иначе - его строковое описание
   return StringFormat("%*s%-*s%-s",indent,"",w,header,back_color==0xFF000000 ? "Default" : ColorToString(back_color,true));
   /* Пример вывода:
   Background color: Default
   */
  }

Для цвета фона может быть задан полностью прозрачный цвет, который ColorToString() возвращает как чёрный (0, 0, 0). Но это не так. Это так называемый цвет по умолчанию: 0xFF000000 — CLR_DEFAULT. У него RGB — нулевые, что соответствует чёрному цвету, но он полностью прозрачен. У дефолтного цвета есть альфа-канал, задающий фону полную прозрачность 0xFF000000. Поэтому прежде, чем вывести название цвета посредством ColorToString(), проверяем его на равенство с CLR_DEFAULT.

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цвет фона, которым подсвечивается               |
//| символ в Market Watch                                            |
//+------------------------------------------------------------------+
void SymbolBackgroundColorPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBackgroundColor(symbol,header_width,indent));
  }


Цена для построения баров (SYMBOL_CHART_MODE)

Тип цены для построения баров – Bid или Last.

//+------------------------------------------------------------------+
//| Возвращает как строку тип цены для построения баров              |
//+------------------------------------------------------------------+
string SymbolChartMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем тип цены для построения баров
   ENUM_SYMBOL_CHART_MODE symbol_chart_mode=(ENUM_SYMBOL_CHART_MODE)SymbolInfoInteger(symbol,SYMBOL_CHART_MODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование типа цены
   string chart_mode=StringSubstr(EnumToString(symbol_chart_mode),18);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(chart_mode.Lower())
      chart_mode.SetChar(0,ushort(chart_mode.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Chart mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,chart_mode);
   /* Пример вывода:
      Chart mode: Bid
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал тип цены для построения баров                   |
//+------------------------------------------------------------------+
void SymbolChartModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolChartMode(symbol,header_width,indent));
  }


Существование символа (SYMBOL_EXIST)

Признак того, что символ с таким именем существует.

//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ с таким именем существует                             |
//+------------------------------------------------------------------+
string SymbolExists(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Exists:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_EXIST) ? "Yes" : "No");
   /* Пример вывода:
   Exists: Yes
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что символ с таким именем существует                             |
//+------------------------------------------------------------------+
void SymbolExistsPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExists(symbol,header_width,indent));
  }


Выбран в Market Watch (SYMBOL_SELECT)

Признак того, что символ выбран в Market Watch.

//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ выбран в Market Watch                                 |
//+------------------------------------------------------------------+
string SymbolSelected(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Selected:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_SELECT) ? "Yes" : "No");
   /* Пример вывода:
   Selected: Yes
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал признак того, что символ выбран в Market Watch  |
//+------------------------------------------------------------------+
void SymbolSelectedPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSelected(symbol,header_width,indent));
  }


Отображается в Market Watch (SYMBOL_VISIBLE)

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

//+------------------------------------------------------------------+
//| Возвращает как строку признак того,                              |
//| что символ отображается в Market Watch                           |
//+------------------------------------------------------------------+
string SymbolVisible(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Visible:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_VISIBLE) ? "Yes" : "No");
   /* Пример вывода:
   Visible: Yes
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал признак того,                                   |
//| что символ отображается в Market Watch                           |
//+------------------------------------------------------------------+
void SymbolVisiblePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVisible(symbol,header_width,indent));
  }


Количество сделок в текущей сессии (SYMBOL_SESSION_DEALS)

//+------------------------------------------------------------------+
//| Возвращает как строку количество сделок в текущей сессии         |
//+------------------------------------------------------------------+
string SymbolSessionDeals(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session deals:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SESSION_DEALS));
   /* Пример вывода:
      Session deals: 0
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал количество сделок в текущей сессии              |
//+------------------------------------------------------------------+
void SymbolSessionDealsPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionDeals(symbol,header_width,indent));
  }


Количество ордеров на покупку (SYMBOL_SESSION_BUY_ORDERS)

Общее число ордеров на покупку в текущий момент

//+------------------------------------------------------------------+
//| Возвращает как строку общее число                                |
//| ордеров на покупку в текущий момент                              |
//+------------------------------------------------------------------+
string SymbolSessionBuyOrders(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Buy orders:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SESSION_BUY_ORDERS));
   /* Пример вывода:
      Session Buy orders: 0
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал общее число ордеров на покупку в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionBuyOrdersPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionBuyOrders(symbol,header_width,indent));
  }


Количество ордеров на продажу (SYMBOL_SESSION_SELL_ORDERS)

Общее число ордеров на продажу в текущий момент.

//+------------------------------------------------------------------+
//| Возвращает как строку общее число                                |
//| ордеров на продажу в текущий момент                              |
//+------------------------------------------------------------------+
string SymbolSessionSellOrders(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Sell orders:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SESSION_BUY_ORDERS));
   /* Пример вывода:
      Session Sell orders: 0
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал общее число ордеров на продажу в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionSellOrdersPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionSellOrders(symbol,header_width,indent));
  }


Объем в последней сделке (SYMBOL_VOLUME)

Volume — объем в последней сделке.

//+------------------------------------------------------------------+
//| Возвращает как строку объем в последней сделке                   |
//+------------------------------------------------------------------+
string SymbolVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_VOLUME));
   /* Пример вывода:
      Volume: 0
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал объем в последней сделке                        |
//+------------------------------------------------------------------+
void SymbolVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolume(symbol,header_width,indent));
  }


Максимальный объем за день (SYMBOL_VOLUMEHIGH)

//+------------------------------------------------------------------+
//| Возвращает как строку максимальный объем за день                 |
//+------------------------------------------------------------------+
string SymbolVolumeHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume high:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_VOLUMEHIGH));
   /* Пример вывода:
      Volume high: 0
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимальный объем за день                      |
//+------------------------------------------------------------------+
void SymbolVolumeHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeHigh(symbol,header_width,indent));
  }


Минимальный объем за день (SYMBOL_VOLUMELOW)

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный объем за день                  |
//+------------------------------------------------------------------+
string SymbolVolumeLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-llu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_VOLUMELOW));
   /* Пример вывода:
      Volume low: 0
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный объем за день                       |
//+------------------------------------------------------------------+
void SymbolVolumeLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeLow(symbol,header_width,indent));
  }


Время последней котировки (SYMBOL_TIME)

//+------------------------------------------------------------------+
//| Возвращает как строку время последней котировки                  |
//+------------------------------------------------------------------+
string SymbolTime(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Time:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(string)(datetime)SymbolInfoInteger(symbol,SYMBOL_TIME));
   /* Пример вывода:
      Time: 2023.07.13 21:05:12
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал время последней котировки                       |
//+------------------------------------------------------------------+
void SymbolTimePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTime(symbol,header_width,indent));
  }


Время последней котировки в мс (SYMBOL_TIME_MSC)

Время последней котировки в миллисекундах с 1970.01.01.

//+------------------------------------------------------------------+
//| Возвращает как строку время последней котировки в миллисекундах  |
//+------------------------------------------------------------------+
string SymbolTimeMSC(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Time msc:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,TimeMSC(SymbolInfoInteger(symbol,SYMBOL_TIME_MSC)));
   /* Пример вывода:
      Time msc: 2023.07.13 21:09:24.327
   */
  }

Здесь для получения строки даты-времени с миллисекундами используем функцию TimeMSC(), написанную в самом начале.

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал время последней котировки в миллисекундах       |
//+------------------------------------------------------------------+
void SymbolTimeMSCPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTimeMSC(symbol,header_width,indent));
  }


Digits (SYMBOL_DIGITS)

Количество знаков после запятой.

//+------------------------------------------------------------------+
//| Возвращает как строку количество знаков после запятой            |
//+------------------------------------------------------------------+
string SymbolDigits(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Digits:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_DIGITS));
   /* Пример вывода:
      Digits: 5
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал количество знаков после запятой                 |
//+------------------------------------------------------------------+
void SymbolDigitsPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolDigits(symbol,header_width,indent));
  }


Спред (SYMBOL_SPREAD)

Размер спреда в пунктах.

//+------------------------------------------------------------------+
//| Возвращает как строку размер спреда в пунктах                    |
//+------------------------------------------------------------------+
string SymbolSpread(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Spread:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_SPREAD));
   /* Пример вывода:
      Spread: 7
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал размер спреда в пунктах                         |
//+------------------------------------------------------------------+
void SymbolSpreadPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSpread(symbol,header_width,indent));
  }


Плавающий спред (SYMBOL_SPREAD_FLOAT)

Признак плавающего спреда

//+------------------------------------------------------------------+
//| Возвращает как строку признак плавающего спреда                  |
//+------------------------------------------------------------------+
string SymbolSpreadFloat(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Floating Spread:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_SPREAD_FLOAT) ? "Yes" : "No");
   /* Пример вывода:
   Spread float: Yes
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал признак плавающего спреда                       |
//+------------------------------------------------------------------+
void SymbolSpreadFloatPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSpreadFloat(symbol,header_width,indent));
  }


Количество заявок в стакане (SYMBOL_TICKS_BOOKDEPTH)

Максимальное количество показываемых заявок в стакане. Для инструментов, не имеющих очереди заявок, значение равно 0.

//+------------------------------------------------------------------+
//| Возвращает как строку максимальное количество                    |
//| показываемых заявок в стакане                                    |
//+------------------------------------------------------------------+
string SymbolTicksBookDepth(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ticks book depth:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu",indent,"",w,header,SymbolInfoInteger(symbol,SYMBOL_TICKS_BOOKDEPTH));
   /* Пример вывода:
      Ticks book depth: 10
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимальное количество                         |
//| показываемых заявок в стакане                                    |
//+------------------------------------------------------------------+
void SymbolTicksBookDepthPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTicksBookDepth(symbol,header_width,indent));
  }


Способ вычисления стоимости контракта (SYMBOL_TRADE_CALC_MODE)

Способ вычисления стоимости контракта.

//+------------------------------------------------------------------+
//| Возвращает как строку способ вычисления стоимости контракта      |
//+------------------------------------------------------------------+
string SymbolTradeCalcMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение способа вычисления стоимости контракта
   ENUM_SYMBOL_CALC_MODE symbol_trade_calc_mode=(ENUM_SYMBOL_CALC_MODE)SymbolInfoInteger(symbol,SYMBOL_TRADE_CALC_MODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование способа вычисления стоимости контракта
   string trade_calc_mode=StringSubstr(EnumToString(symbol_trade_calc_mode),17);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(trade_calc_mode.Lower())
      trade_calc_mode.SetChar(0,ushort(trade_calc_mode.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(trade_calc_mode,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Trade calculation mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,trade_calc_mode);
   /* Пример вывода:
      Trade calculation mode: Forex
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал способ вычисления стоимости контракта           |
//+------------------------------------------------------------------+
void SymbolTradeCalcModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeCalcMode(symbol,header_width,indent));
  }


Тип исполнения ордеров (SYMBOL_TRADE_MODE)

Тип исполнения ордеров.

//+------------------------------------------------------------------+
//| Возвращает как строку тип исполнения ордеров                     |
//+------------------------------------------------------------------+
string SymbolTradeMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение способа вычисления стоимости контракта
   ENUM_SYMBOL_TRADE_MODE symbol_trade_mode=(ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(symbol,SYMBOL_TRADE_MODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование способа вычисления стоимости контракта
   string trade_mode=StringSubstr(EnumToString(symbol_trade_mode),18);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(trade_mode.Lower())
      trade_mode.SetChar(0,ushort(trade_mode.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Trade mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,trade_mode);
   /* Пример вывода:
      Trade mode: Full
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал тип исполнения ордеров                          |
//+------------------------------------------------------------------+
void SymbolTradeModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeMode(symbol,header_width,indent));
  }


Дата начала торгов (SYMBOL_START_TIME)

Дата начала торгов по инструменту (обычно используется для фьючерсов).

//+------------------------------------------------------------------+
//| Возвращает как строку дату начала торгов по инструменту          |
//+------------------------------------------------------------------+
string SymbolStartTime(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Start time:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   long time=SymbolInfoInteger(symbol,SYMBOL_START_TIME);
   string descr=(time==0 ? " (Not used)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s%s",indent,"",w,header,(string)(datetime)time,descr);
   /* Пример вывода:
      Start time: 1970.01.01 00:00:00 (Not used)
   */
  }

Если значение не задано (равно нулю), то оно как дата выводится в виде 1970.01.01. 00:00:00. Немного сбивает с толку. Поэтому в такой ситуации следом за значением даты и времени выводится пояснение "Not used".

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал дату начала торгов по инструменту               |
//+------------------------------------------------------------------+
void SymbolSymbolStartTimePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolStartTime(symbol,header_width,indent));
  }


Дата окончания торгов

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

//+------------------------------------------------------------------+
//| Возвращает как строку дату окончания торгов по инструменту       |
//+------------------------------------------------------------------+
string SymbolExpirationTime(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Expiration time:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   long time=SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_TIME);
   string descr=(time==0 ? " (Not used)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s%s",indent,"",w,header,(string)(datetime)time,descr);
   /* Пример вывода:
      Expiration time: 1970.01.01 00:00:00 (Not used)
   */
  }

Если значение не задано (равно нулю), то следом за значением даты и времени выводится пояснение "Not used".

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал дату окончания торгов по инструменту            |
//+------------------------------------------------------------------+
void SymbolSymbolExpirationTimePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExpirationTime(symbol,header_width,indent));
  }


Stops Level (SYMBOL_TRADE_STOPS_LEVEL)

Минимальный отступ в пунктах от текущей цены закрытия для установки Stop ордеров.

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный отступ в пунктах               |
//| от текущей цены закрытиядля установки Stop ордеров               |
//+------------------------------------------------------------------+
string SymbolTradeStopsLevel(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Stops level:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   int stops_level=(int)SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL);
   string descr=(stops_level==0 ? " (By Spread)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu%s",indent,"",w,header,stops_level,descr);
   /* Пример вывода:
      Stops level: 0 (By Spread)
   */
  }

Если значение равно нулю, то это не означает нулевой уровень установки стопов или его отсутствие. Это означает, что Stops Level зависит от значения Spread. Обычно 2 * Spread, о чём и выводится поясняющая запись "By Spread".

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный отступ в пунктах от текущей         |
//| цены закрытия для установки Stop ордеров                         |
//+------------------------------------------------------------------+
void SymbolTradeStopsLevelPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeStopsLevel(symbol,header_width,indent));
  }


Freeze Level (SYMBOL_TRADE_FREEZE_LEVEL)

Дистанция заморозки торговых операций (в пунктах).

//+------------------------------------------------------------------+
//| Возвращает как строку дистанцию заморозки                        |
//| торговых операций в пунктах                                      |
//+------------------------------------------------------------------+
string SymbolTradeFreezeLevel(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Freeze level:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение свойства и определяем его описание
   int freeze_level=(int)SymbolInfoInteger(symbol,SYMBOL_TRADE_FREEZE_LEVEL);
   string descr=(freeze_level==0 ? " (Not used)" : "");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-lu%s",indent,"",w,header,freeze_level,descr);
   /* Пример вывода:
      Freeze level: 0 (Not used)
   */
  }

Если значение равно нулю, то это означает, что Freeze Level не используется, о чём и выводится поясняющая запись "Not used".

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал дистанцию заморозки торговых операций в пунктах |
//+------------------------------------------------------------------+
void SymbolTradeFreezeLevelPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeFreezeLevel(symbol,header_width,indent));
  }


Режим заключения сделок (SYMBOL_TRADE_EXEMODE)

Режим заключения сделок.

//+------------------------------------------------------------------+
//| Возвращает как строку режим заключения сделок                    |
//+------------------------------------------------------------------+
string SymbolTradeExeMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение способа вычисления стоимости контракта
   ENUM_SYMBOL_TRADE_EXECUTION symbol_trade_exemode=(ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(symbol,SYMBOL_TRADE_EXEMODE);
//--- "Вырезаем" из строки, полученной из enum, только наименование способа вычисления стоимости контракта
   string trade_exemode=StringSubstr(EnumToString(symbol_trade_exemode),23);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(trade_exemode.Lower())
      trade_exemode.SetChar(0,ushort(trade_exemode.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Trade Execution mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,trade_exemode);
   /* Пример вывода:
      Trade Execution mode: Instant
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал режим заключения сделок                         |
//+------------------------------------------------------------------+
void SymbolTradeExeModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeExeMode(symbol,header_width,indent));
  }


Модель расчета свопа (SYMBOL_SWAP_MODE)

Модель расчёта свопа.

//+------------------------------------------------------------------+
//| Возвращает как строку модель расчета свопа                       |
//+------------------------------------------------------------------+
string SymbolSwapMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение модели расчета свопа
   ENUM_SYMBOL_SWAP_MODE symbol_swap_mode=(ENUM_SYMBOL_SWAP_MODE)SymbolInfoInteger(symbol,SYMBOL_SWAP_MODE);
//--- "Вырезаем" из строки, полученной из enum, только модель расчета свопа
   string swap_mode=StringSubstr(EnumToString(symbol_swap_mode),17);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(swap_mode.Lower())
      swap_mode.SetChar(0,ushort(swap_mode.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(swap_mode,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,swap_mode);
   /* Пример вывода:
      Swap mode: Points
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал модель расчета свопа                            |
//+------------------------------------------------------------------+
void SymbolSwapModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapMode(symbol,header_width,indent));
  }


День начисления тройного свопа (SYMBOL_SWAP_ROLLOVER3DAYS)

День недели для начисления тройного свопа.

//+------------------------------------------------------------------+
//| Возвращает как строку день недели для начисления тройного свопа  |
//+------------------------------------------------------------------+
string SymbolSwapRollover3Days(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение модели расчета свопа
   ENUM_DAY_OF_WEEK symbol_swap_rollover3days=(ENUM_DAY_OF_WEEK)SymbolInfoInteger(symbol,SYMBOL_SWAP_ROLLOVER3DAYS);
//--- Переобразуем enum в строку с наименованием дня недели
   string swap_rollover3days=EnumToString(symbol_swap_rollover3days);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(swap_rollover3days.Lower())
      swap_rollover3days.SetChar(0,ushort(swap_rollover3days.GetChar(0)-0x20));
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Rollover 3 days:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,swap_rollover3days);
   /* Пример вывода:
      Swap Rollover 3 days: Wednesday
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал день недели для начисления тройного свопа       |
//+------------------------------------------------------------------+
void SymbolSwapRollover3DaysPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapRollover3Days(symbol,header_width,indent));
  }


Режим расчета хеджированной маржи (SYMBOL_MARGIN_HEDGED_USE_LEG)

Режим расчета хеджированной маржи по наибольшей стороне (Buy или Sell).

//+------------------------------------------------------------------+
//| Возвращает как строку режим расчета                              |
//| хеджированной маржи по наибольшей стороне                        |
//+------------------------------------------------------------------+
string SymbolMarginHedgedUseLeg(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin hedged use leg:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,(bool)SymbolInfoInteger(symbol,SYMBOL_MARGIN_HEDGED_USE_LEG) ? "Yes" : "No");
   /* Пример вывода:
   Margin hedged use leg: No
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал режим расчета хеджированной                     |
//| маржи по наибольшей стороне                                      |
//+------------------------------------------------------------------+
void SymbolMarginHedgedUseLegPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginHedgedUseLeg(symbol,header_width,indent));
  }


Флаги режимов истечения ордеров (SYMBOL_EXPIRATION_MODE)

Для каждого финансового инструмента могут быть указаны несколько режимов срока действия (истечения) отложенных ордеров. Каждому режиму сопоставлен флаг, флаги могут комбинироваться операцией логического ИЛИ (|), например, SYMBOL_EXPIRATION_GTC|SYMBOL_EXPIRATION_SPECIFIED. Чтобы проверить разрешенность конкретного режима для инструмента, необходимо результат логического И (&) сравнить с флагом режима.

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

//+------------------------------------------------------------------+
//| Возвращает как строку флаги разрешенных режимов истечения ордера |
//+------------------------------------------------------------------+
string SymbolExpirationMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем режимы истечения ордера
   int exp_mode=(int)SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_MODE);
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Expiration mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);

//--- Разбираем флаги режимов на составляющие
   string flags="";
   if((exp_mode&SYMBOL_EXPIRATION_GTC)==SYMBOL_EXPIRATION_GTC)
      flags+=(flags.Length()>0 ? "|" : "")+"GTC";
   if((exp_mode&SYMBOL_EXPIRATION_DAY)==SYMBOL_EXPIRATION_DAY)
      flags+=(flags.Length()>0 ? "|" : "")+"DAY";
   if((exp_mode&SYMBOL_EXPIRATION_SPECIFIED)==SYMBOL_EXPIRATION_SPECIFIED)
      flags+=(flags.Length()>0 ? "|" : "")+"SPECIFIED";
   if((exp_mode&SYMBOL_EXPIRATION_SPECIFIED_DAY)==SYMBOL_EXPIRATION_SPECIFIED_DAY)
      flags+=(flags.Length()>0 ? "|" : "")+"SPECIFIED_DAY";

//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,flags);
   /* Пример вывода:
   Expiration mode: GTC|DAY|SPECIFIED
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал флаги разрешенных режимов истечения ордера      |
//+------------------------------------------------------------------+
void SymbolExpirationModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExpirationMode(symbol,header_width,indent));
  }


Флаги режимов заливки ордеров (SYMBOL_FILLING_MODE)

Флаги разрешенных режимов заливки ордера.

При отправке ордера можно указать политику заполнения заявленного в торговом приказе объема. Для каждого инструмента может быть установлен не один режим, а несколько через комбинацию флагов. Комбинация флагов выражается операцией логического ИЛИ (|), например, SYMBOL_FILLING_FOK|SYMBOL_FILLING_IOC. Тип заливки ORDER_FILLING_RETURN разрешен при любых режимах исполнения, кроме режима "Исполнение по рынку" (SYMBOL_TRADE_EXECUTION_MARKET). 
//+------------------------------------------------------------------+
//| Возвращает как строку флаги разрешенных режимов заливки ордера   |
//+------------------------------------------------------------------+
string SymbolFillingMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем режимы заливки ордера
   int fill_mode=(int)SymbolInfoInteger(symbol,SYMBOL_FILLING_MODE);
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Filling mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);

//--- Разбираем флаги режимов на составляющие
   string flags="";
   if((fill_mode&ORDER_FILLING_FOK)==ORDER_FILLING_FOK)
      flags+=(flags.Length()>0 ? "|" : "")+"FOK";
   if((fill_mode&ORDER_FILLING_IOC)==ORDER_FILLING_IOC)
      flags+=(flags.Length()>0 ? "|" : "")+"IOC";
   if((fill_mode&ORDER_FILLING_BOC)==ORDER_FILLING_BOC)
      flags+=(flags.Length()>0 ? "|" : "")+"BOC";
   if(SymbolInfoInteger(symbol,SYMBOL_TRADE_EXEMODE)!=SYMBOL_TRADE_EXECUTION_MARKET)
      flags+=(flags.Length()>0 ? "|" : "")+"RETURN";

//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,flags);
   /* Пример вывода:
   Filling mode: FOK|IOC|RETURN
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал флаги разрешенных режимов заливки ордера        |
//+------------------------------------------------------------------+
void SymbolFillingModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolFillingMode(symbol,header_width,indent));
  }


Флаги разрешенных типов ордеров (SYMBOL_ORDER_MODE)

//+------------------------------------------------------------------+
//| Возвращает как строку флаги разрешенных типов ордера             |
//+------------------------------------------------------------------+
string SymbolOrderMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем типы ордера
   int order_mode=(int)SymbolInfoInteger(symbol,SYMBOL_ORDER_MODE);
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Order mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);

//--- Разбираем флаги типов на составляющие
   string flags="";
   if((order_mode&SYMBOL_ORDER_MARKET)==SYMBOL_ORDER_MARKET)
      flags+=(flags.Length()>0 ? "|" : "")+"MARKET";
   if((order_mode&SYMBOL_ORDER_LIMIT)==SYMBOL_ORDER_LIMIT)
      flags+=(flags.Length()>0 ? "|" : "")+"LIMIT";
   if((order_mode&SYMBOL_ORDER_STOP)==SYMBOL_ORDER_STOP)
      flags+=(flags.Length()>0 ? "|" : "")+"STOP";
   if((order_mode&SYMBOL_ORDER_STOP_LIMIT )==SYMBOL_ORDER_STOP_LIMIT )
      flags+=(flags.Length()>0 ? "|" : "")+"STOP_LIMIT";
   if((order_mode&SYMBOL_ORDER_SL)==SYMBOL_ORDER_SL)
      flags+=(flags.Length()>0 ? "|" : "")+"SL";
   if((order_mode&SYMBOL_ORDER_TP)==SYMBOL_ORDER_TP)
      flags+=(flags.Length()>0 ? "|" : "")+"TP";
   if((order_mode&SYMBOL_ORDER_CLOSEBY)==SYMBOL_ORDER_CLOSEBY)
      flags+=(flags.Length()>0 ? "|" : "")+"CLOSEBY";

//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,flags);
   /* Пример вывода:
   Order mode: MARKET|LIMIT|STOP|STOP_LIMIT|SL|TP|CLOSEBY
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал флаги разрешенных типов ордера                  |
//+------------------------------------------------------------------+
void SymbolOrderModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOrderMode(symbol,header_width,indent));
  }


Срок действия StopLoss и TakeProfit ордеров (SYMBOL_ORDER_GTC_MODE)

Срок действия  StopLoss и TakeProfit ордеров, если SYMBOL_EXPIRATION_MODE=SYMBOL_EXPIRATION_GTC (Good till cancelled).

//+------------------------------------------------------------------+
//| Возвращает как строку срок действия StopLoss и TakeProfit ордеров|
//+------------------------------------------------------------------+
string SymbolOrderGTCMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение срока действия отложенных ордеров, StopLoss и TakeProfit ордеров
   ENUM_SYMBOL_ORDER_GTC_MODE symbol_order_gtc_mode=(ENUM_SYMBOL_ORDER_GTC_MODE)SymbolInfoInteger(symbol,SYMBOL_ORDER_GTC_MODE);
//--- Устанавливаем описание срока действия как 'GTC'
   string gtc_mode="GTC";
//--- Если срок действия не GTC
   if(symbol_order_gtc_mode!=SYMBOL_ORDERS_GTC)
     {
      //--- "Вырезаем" из строки, полученной из enum, только описание срока действия отложенных ордеров, StopLoss и TakeProfit ордеров
      StringSubstr(EnumToString(symbol_order_gtc_mode),14);
      //--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
      if(gtc_mode.Lower())
         gtc_mode.SetChar(0,ushort(gtc_mode.GetChar(0)-0x20));
      //--- Заменяем в полученной строке все символы подчёркивания на символ пробела
      StringReplace(gtc_mode,"_"," ");
     }
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Order GTC mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,gtc_mode);
   /* Пример вывода:
      Order GTC mode: GTC
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал срок действия  StopLoss и TakeProfit ордеров    |
//+------------------------------------------------------------------+
void SymbolOrderGTCModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOrderGTCMode(symbol,header_width,indent));
  }


Тип опциона (SYMBOL_OPTION_MODE)

Тип опциона.

//+------------------------------------------------------------------+
//| Возвращает как строку тип опциона                                |
//+------------------------------------------------------------------+
string SymbolOptionMode(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение модели типа опциона
   ENUM_SYMBOL_OPTION_MODE symbol_option_mode=(ENUM_SYMBOL_OPTION_MODE)SymbolInfoInteger(symbol,SYMBOL_OPTION_MODE);
//--- "Вырезаем" из строки, полученной из enum, только тип опциона
   string option_mode=StringSubstr(EnumToString(symbol_option_mode),19);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(option_mode.Lower())
      option_mode.SetChar(0,ushort(option_mode.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(option_mode,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Option mode:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,option_mode);
   /* Пример вывода:
      Option mode: European
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал тип опциона                                     |
//+------------------------------------------------------------------+
void SymbolOptionModePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOptionMode(symbol,header_width,indent));
  }


Право опциона (SYMBOL_OPTION_RIGHT)

Право опциона (Call/Put).

//+------------------------------------------------------------------+
//| Возвращает как строку право опциона                              |
//+------------------------------------------------------------------+
string SymbolOptionRight(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Получаем значение права опциона
   ENUM_SYMBOL_OPTION_RIGHT symbol_option_right=(ENUM_SYMBOL_OPTION_RIGHT)SymbolInfoInteger(symbol,SYMBOL_OPTION_RIGHT);
//--- "Вырезаем" из строки, полученной из enum, только право опциона
   string option_right=StringSubstr(EnumToString(symbol_option_right),20);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(option_right.Lower())
      option_right.SetChar(0,ushort(option_right.GetChar(0)-0x20));
//--- Заменяем в полученной строке все символы подчёркивания на символ пробела
   StringReplace(option_right,"_"," ");
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Option right:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-s",indent,"",w,header,option_right);
   /* Пример вывода:
      Option right: Call
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал право опциона                                   |
//+------------------------------------------------------------------+
void SymbolOptionRightPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOptionRight(symbol,header_width,indent));
  }


Получение и вывод вещественных свойств символа ENUM_SYMBOL_INFO_DOUBLE

Цена Bid (SYMBOL_BID)

Bid — лучшее предложение на продажу.

//+------------------------------------------------------------------+
//| Возвращает как строку цену Bid                                   |
//+------------------------------------------------------------------+
string SymbolBid(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bid:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_BID));
   /* Пример вывода:
   Bid: 1.31017
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цену Bid                                        |
//+------------------------------------------------------------------+
void SymbolBidPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBid(symbol,header_width,indent));
  }


Максимальный Bid за день (SYMBOL_BIDHIGH)

//+------------------------------------------------------------------+
//| Возвращает как строку максимальный Bid за день                   |
//+------------------------------------------------------------------+
string SymbolBidHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bid High:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_BIDHIGH));
   /* Пример вывода:
   Bid High: 1.31422
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимальный Bid за день                        |
//+------------------------------------------------------------------+
void SymbolBidHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBidHigh(symbol,header_width,indent));
  }


Минимальный Bid за день (SYMBOL_BIDLOW)

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный Bid за день                    |
//+------------------------------------------------------------------+
string SymbolBidLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bid Low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_BIDLOW));
   /* Пример вывода:
   Bid Low: 1.30934
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный Bid за день                         |
//+------------------------------------------------------------------+
void SymbolBidLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBidLow(symbol,header_width,indent));
  }


Цена Ask (SYMBOL_ASK)

Ask — лучшее предложение на покупку.

//+------------------------------------------------------------------+
//| Возвращает как строку цену Ask                                   |
//+------------------------------------------------------------------+
string SymbolAsk(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ask:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_ASK));
   /* Пример вывода:
   Ask: 1.31060
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цену Ask                                        |
//+------------------------------------------------------------------+
void SymbolAskPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolAsk(symbol,header_width,indent));
  }


Максимальный Ask за день (SYMBOL_ASKHIGH)

//+------------------------------------------------------------------+
//| Возвращает как строку максимальный Ask за день                   |
//+------------------------------------------------------------------+
string SymbolAskHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ask High:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_ASKHIGH));
   /* Пример вывода:
   Ask High: 1.31427
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимальный Ask за день                        |
//+------------------------------------------------------------------+
void SymbolAskHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolAskHigh(symbol,header_width,indent));
  }


Минимальный Ask за день (SYMBOL_ASKLOW)

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный Ask за день                    |
//+------------------------------------------------------------------+
string SymbolAskLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Ask Low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_ASKLOW));
   /* Пример вывода:
   Ask Low: 1.30938
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный Ask за день                         |
//+------------------------------------------------------------------+
void SymbolAskLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolAskLow(symbol,header_width,indent));
  }


Цена Last (SYMBOL_LAST)

Цена, по которой совершена последняя сделка.

//+------------------------------------------------------------------+
//| Возвращает как строку цену Last                                  |
//+------------------------------------------------------------------+
string SymbolLast(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Last:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_LAST));
   /* Пример вывода:
   Last: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цену Last                                       |
//+------------------------------------------------------------------+
void SymbolLastPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolLast(symbol,header_width,indent));
  }


Максимальный Last за день (SYMBOL_LASTHIGH)

//+------------------------------------------------------------------+
//| Возвращает как строку максимальный Last за день                  |
//+------------------------------------------------------------------+
string SymbolLastHigh(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Last High:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_LASTHIGH));
   /* Пример вывода:
   Last High: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимальный Last за день                       |
//+------------------------------------------------------------------+
void SymbolLastHighPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolLastHigh(symbol,header_width,indent));
  }


Минимальный Last за день (SYMBOL_LASTLOW)

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный Last за день                   |
//+------------------------------------------------------------------+
string SymbolLastLow(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Last Low:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_LASTLOW));
   /* Пример вывода:
   Last Low: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный Last за день                        |
//+------------------------------------------------------------------+
void SymbolLastLowPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolLastLow(symbol,header_width,indent));
  }


Объем последней сделки (SYMBOL_VOLUME_REAL)

Объем последней совершенной сделки

//+------------------------------------------------------------------+
//| Возвращает как строку объем последней совершенной сделки         |
//+------------------------------------------------------------------+
string SymbolVolumeReal(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume real:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_VOLUME_REAL));
   /* Пример вывода:
   Volume real: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал объем последней совершенной сделки              |
//+------------------------------------------------------------------+
void SymbolVolumeRealPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeReal(symbol,header_width,indent));
  }


Максимальный объем за день (SYMBOL_VOLUMEHIGH_REAL)

//+------------------------------------------------------------------+
//| Возвращает как строку максимальный объем за день                 |
//+------------------------------------------------------------------+
string SymbolVolumeHighReal(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume High real:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_VOLUMEHIGH_REAL));
   /* Пример вывода:
   Volume High real: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимальный объем за день                      |
//+------------------------------------------------------------------+
void SymbolVolumeHighRealPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeHighReal(symbol,header_width,indent));
  }


Минимальный объем за день (SYMBOL_VOLUMELOW_REAL)

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный объем за день                  |
//+------------------------------------------------------------------+
string SymbolVolumeLowReal(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume Low real:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_VOLUMELOW_REAL));
   /* Пример вывода:
   Volume Low real: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный объем за день                       |
//+------------------------------------------------------------------+
void SymbolVolumeLowRealPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeLowReal(symbol,header_width,indent));
  }


Цена исполнения опциона (SYMBOL_OPTION_STRIKE)

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

//+------------------------------------------------------------------+
//| Возвращает как строку цену исполнения опциона                    |
//+------------------------------------------------------------------+
string SymbolOptionStrike(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Option strike:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_OPTION_STRIKE));
   /* Пример вывода:
   Option strike: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цену исполнения опциона                         |
//+------------------------------------------------------------------+
void SymbolOptionStrikePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolOptionStrike(symbol,header_width,indent));
  }


Point (SYMBOL_POINT)

Значение одного пункта

//+------------------------------------------------------------------+
//| Возвращает как строку значение одного пункта                     |
//+------------------------------------------------------------------+
string SymbolPoint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Point:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_POINT));
   /* Пример вывода:
   Point: 0.00001
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал значение одного пункта                          |
//+------------------------------------------------------------------+
void SymbolPointPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPoint(symbol,header_width,indent));
  }


Стоимость тика (SYMBOL_TRADE_TICK_VALUE)

Значение SYMBOL_TRADE_TICK_VALUE_PROFIT — рассчитанная стоимость тика для прибыльной позиции.

//+------------------------------------------------------------------+
//| Возвращает как строку стоимость тика                             |
//+------------------------------------------------------------------+
string SymbolTradeTickValue(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick value:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE));
   /* Пример вывода:
   Tick value: 1.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал стоимость тика                                  |
//+------------------------------------------------------------------+
void SymbolTradeTickValuePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickValue(symbol,header_width,indent));
  }


Стоимость тика для прибыльной позиции (SYMBOL_TRADE_TICK_VALUE_PROFIT)

Рассчитанная стоимость тика для прибыльной позиции.

//+------------------------------------------------------------------+
//| Возвращает как строку рассчитанную стоимость тика                |
//| для прибыльной позиции                                           |
//+------------------------------------------------------------------+
string SymbolTradeTickValueProfit(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick value profit:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE_PROFIT));
   /* Пример вывода:
   Tick value profit: 1.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал рассчитанную стоимость тика                     |
//| для прибыльной позиции                                           |
//+------------------------------------------------------------------+
void SymbolTradeTickValueProfitPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickValueProfit(symbol,header_width,indent));
  }


Стоимость тика для убыточной позиции (SYMBOL_TRADE_TICK_VALUE_LOSS)

Рассчитанная стоимость тика для убыточной позиции.

//+------------------------------------------------------------------+
//| Возвращает как строку рассчитанную стоимость тика                |
//| для убыточной позиции                                            |
//+------------------------------------------------------------------+
string SymbolTradeTickValueLoss(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick value loss:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE_LOSS));
   /* Пример вывода:
   Tick value loss: 1.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал рассчитанную стоимость тика                     |
//| для убыточной позиции                                            |
//+------------------------------------------------------------------+
void SymbolTradeTickValueLossPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickValueLoss(symbol,header_width,indent));
  }


Минимальное изменение цены (SYMBOL_TRADE_TICK_SIZE)

//+------------------------------------------------------------------+
//| Возвращает как строку минимальное изменение цены                 |
//+------------------------------------------------------------------+
string SymbolTradeTickSize(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Tick size:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_SIZE));
   /* Пример вывода:
   Tick size: 0.00001
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальное изменение цены                      |
//+------------------------------------------------------------------+
void SymbolTradeTickSizePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeTickSize(symbol,header_width,indent));
  }


Размер торгового контракта (SYMBOL_TRADE_CONTRACT_SIZE)

//+------------------------------------------------------------------+
//| Возвращает как строку размер торгового контракта                 |
//+------------------------------------------------------------------+
string SymbolTradeContractSize(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Contract size:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %s",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE),SymbolInfoString(symbol,SYMBOL_CURRENCY_BASE));
   /* Пример вывода:
   Contract size: 100000.00 GBP
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал размер торгового контракта                      |
//+------------------------------------------------------------------+
void SymbolTradeContractSizePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeContractSize(symbol,header_width,indent));
  }


Накопленный купонный доход (SYMBOL_TRADE_ACCRUED_INTEREST)

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

//+------------------------------------------------------------------+
//| Возвращает как строку накопленный купонный доход                 |
//+------------------------------------------------------------------+
string SymbolTradeAccruedInterest(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Accrued interest:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_ACCRUED_INTEREST));
   /* Пример вывода:
   Accrued interest: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал накопленный купонный доход                      |
//+------------------------------------------------------------------+
void SymbolTradeAccruedInterestPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeAccruedInterest(symbol,header_width,indent));
  }


Номинальная стоимость (SYMBOL_TRADE_FACE_VALUE)

Номинальная стоимость – начальная стоимость облигации, установленная эмитентом.

//+------------------------------------------------------------------+
//| Возвращает как строку номинальную стоимость                      |
//+------------------------------------------------------------------+
string SymbolTradeFaceValue(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Face value:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_FACE_VALUE));
   /* Пример вывода:
   Face value: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал номинальную стоимость                           |
//+------------------------------------------------------------------+
void SymbolTradeFaceValuePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeFaceValue(symbol,header_width,indent));
  }


Коэффициент ликвидности (SYMBOL_TRADE_LIQUIDITY_RATE)

Коэффициент ликвидности – доля от стоимости актива, которую можно использовать в качестве залога.

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент ликвидности                    |
//+------------------------------------------------------------------+
string SymbolTradeLiquidityRate(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Liquidity rate:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_TRADE_LIQUIDITY_RATE));
   /* Пример вывода:
   Liquidity rate: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент ликвидности                         |
//+------------------------------------------------------------------+
void SymbolTradeLiquidityRatePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolTradeLiquidityRate(symbol,header_width,indent));
  }


Минимальный объем (SYMBOL_VOLUME_MIN)

Минимальный объем для заключения сделки.

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный объем                          |
//+------------------------------------------------------------------+
string SymbolVolumeMin(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume min:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN));
   /* Пример вывода:
   Volume min: 0.01
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный объем                               |
//+------------------------------------------------------------------+
void SymbolVolumeMinPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeMin(symbol,header_width,indent));
  }


Максимальный объем (SYMBOL_VOLUME_MAX)

Максимальный объем для заключения сделки.

//+------------------------------------------------------------------+
//| Возвращает как строку максимальный объем                         |
//+------------------------------------------------------------------+
string SymbolVolumeMax(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume max:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_MAX));
   /* Пример вывода:
   Volume max: 500.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимальный объем                              |
//+------------------------------------------------------------------+
void SymbolVolumeMaxPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeMax(symbol,header_width,indent));
  }


Шаг изменения объема (SYMBOL_VOLUME_STEP)

Минимальный шаг изменения объема для заключения сделки.

//+------------------------------------------------------------------+
//| Возвращает как строку минимальный шаг изменения объема           |
//+------------------------------------------------------------------+
string SymbolVolumeStep(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume step:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP));
   /* Пример вывода:
   Volume step: 0.01
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимальный шаг изменения объема                |
//+------------------------------------------------------------------+
void SymbolVolumeStepPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeStep(symbol,header_width,indent));
  }


Максимальный объем позиции и ордеров в одном направлении (SYMBOL_VOLUME_LIMIT)

Максимально допустимый для данного символа совокупный объем открытой позиции и отложенных ордеров в одном направлении (покупка или продажа). Например, при ограничении в 5 лотов можно иметь открытую позицию на покупку объемом 5 лотов и выставить отложенный ордер Sell Limit объемом 5 лотов. Но при этом нельзя выставить отложенный ордер Buy Limit (поскольку совокупный объем в одном направлении превысит ограничение) или выставить Sell Limit объемом более 5 лотов.

//+------------------------------------------------------------------+
//| Возвращает как строку максимально допустимый для символа         |
//| совокупный объем открытой позиции и отложенных ордеров           |
//+------------------------------------------------------------------+
string SymbolVolumeLimit(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Volume limit:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой в значении лота
   int dg=(int)ceil(fabs(log10(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))));
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_VOLUME_LIMIT));
   /* Пример вывода:
   Volume limit: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимально допустимый для символа              |
//| совокупный объем открытой позиции и отложенных ордеров           |
//+------------------------------------------------------------------+
void SymbolVolumeLimitPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolVolumeLimit(symbol,header_width,indent));
  }


Своп на покупку (SYMBOL_SWAP_LONG)

//+------------------------------------------------------------------+
//| Возвращает как строку значение свопа в покупку                   |
//+------------------------------------------------------------------+
string SymbolSwapLong(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap long:";
   uint w=(header_width==0 ? header.Length()+1 : header_width-1);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%- .2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SWAP_LONG));
   /* Пример вывода:
   Swap long: -0.20
   */
  }

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

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал значение свопа в покупку                        |
//+------------------------------------------------------------------+
void SymbolSwapLongPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapLong(symbol,header_width,indent));
  }


Своп на продажу (SYMBOL_SWAP_SHORT)

//+------------------------------------------------------------------+
//| Возвращает как строку значение свопа в продажу                   |
//+------------------------------------------------------------------+
string SymbolSwapShort(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap short:";
   uint w=(header_width==0 ? header.Length()+1 : header_width-1);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%- .2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SWAP_SHORT));
   /* Пример вывода:
   Swap short: -2.20
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал значение свопа в продажу                        |
//+------------------------------------------------------------------+
void SymbolSwapShortPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapShort(symbol,header_width,indent));
  }


Коэффициент начисления свопов (SYMBOL_SWAP_SUNDAY)

Коэффициент начисления свопов (SYMBOL_SWAP_LONG или SYMBOL_SWAP_SHORT) при переносе позиции с указанного дня (SUNDAY) на следующий. Могут быть следующие значения:

    0 – свопы не начисляются
    1 – одиночное начисление свопов
    3 – тройное начисление свопов

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с воскресения на понедельник                |
//+------------------------------------------------------------------+
string SymbolSwapSunday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap sunday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_SUNDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
   Swap sunday: 0 (no swap is charged)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с воскресения на понедельник                |
//+------------------------------------------------------------------+
void SymbolSwapSundayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapSunday(symbol,header_width,indent));
  }


Коэффициент начисления свопов с понедельника на вторник (SYMBOL_SWAP_MONDAY)

Коэффициент начисления свопов (SYMBOL_SWAP_LONG или SYMBOL_SWAP_SHORT) при переносе позиции с понедельника на вторник.

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с понедельника на вторник                   |
//+------------------------------------------------------------------+
string SymbolSwapMonday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap monday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_MONDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
   Swap monday: 1 (single swap)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с понедельника на вторник                   |
//+------------------------------------------------------------------+
void SymbolSwapMondayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapMonday(symbol,header_width,indent));
  }


Коэффициент начисления свопов со вторника на среду (SYMBOL_SWAP_TUESDAY)

Коэффициент начисления свопов (SYMBOL_SWAP_LONG или SYMBOL_SWAP_SHORT) при переносе позиции со вторника на среду

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции со вторника на среду                        |
//+------------------------------------------------------------------+
string SymbolSwapTuesday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Tuesday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_TUESDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
   Swap Tuesday: 1 (single swap)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции со вторника на среду                        |
//+------------------------------------------------------------------+
void SymbolSwapTuesdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapTuesday(symbol,header_width,indent));
  }


Коэффициент начисления свопов со среды на четверг (SYMBOL_SWAP_WEDNESDAY)

Коэффициент начисления свопов (SYMBOL_SWAP_LONG или SYMBOL_SWAP_SHORT) при переносе позиции со среды на четверг

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции со среды на четверг                         |
//+------------------------------------------------------------------+
string SymbolSwapWednesday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Wednesday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_WEDNESDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Wednesday: 3 (triple swap)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции со среды на четверг                         |
//+------------------------------------------------------------------+
void SymbolSwapWednesdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapWednesday(symbol,header_width,indent));
  }


Коэффициент начисления свопов с четверга на пятницу (SYMBOL_SWAP_THURSDAY)

Коэффициент начисления свопов (SYMBOL_SWAP_LONG или SYMBOL_SWAP_SHORT) при переносе позиции с четверга на пятницу.

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с четверга на пятницу                       |
//+------------------------------------------------------------------+
string SymbolSwapThursday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Thursday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_THURSDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Thursday: 1 (single swap)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с четверга на пятницу                       |
//+------------------------------------------------------------------+
void SymbolSwapThursdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapThursday(symbol,header_width,indent));
  }


Коэффициент начисления свопов с пятницы на субботу (SYMBOL_SWAP_FRIDAY)

Коэффициент начисления свопов (SYMBOL_SWAP_LONG или SYMBOL_SWAP_SHORT) при переносе позиции с пятницы на субботу.

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с пятницы на субботу                        |
//+------------------------------------------------------------------+
string SymbolSwapFriday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Friday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_FRIDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Friday: 1 (single swap)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с пятницы на субботу                        |
//+------------------------------------------------------------------+
void SymbolSwapFridayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapFriday(symbol,header_width,indent));
  }


Коэффициент начисления свопов с субботы на воскресенье (SYMBOL_SWAP_SATURDAY)

Коэффициент начисления свопов (SYMBOL_SWAP_LONG или SYMBOL_SWAP_SHORT) при переносе позиции с субботы на воскресенье.

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| при переносе позиции с субботы на воскресенье                    |
//+------------------------------------------------------------------+
string SymbolSwapSaturday(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Swap Saturday:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем коэффициент и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,SYMBOL_SWAP_SATURDAY);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Saturday: 0 (no swap is charged)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| при переносе позиции с субботы на воскресенье                    |
//+------------------------------------------------------------------+
void SymbolSwapSaturdayPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapSaturday(symbol,header_width,indent));
  }

Итого для вывода коэффициента начисления свопов для каждого дня недели у нас получилось 7 * 2 функций. Но можно сделать одну универсальную функцию, возвращающую строку с описанием коэффициента свопов по указанному дню недели, и одну функцию для распечатки в журнал результата, возвращаемого первой функцией. Напишем:

//+------------------------------------------------------------------+
//| Возвращает как строку коэффициент начисления свопов              |
//| по указанному дню недели                                         |
//+------------------------------------------------------------------+
string SymbolSwapByDay(const string symbol,const ENUM_DAY_OF_WEEK day_week,const uint header_width=0,const uint indent=0)
  {
//--- Получаем текстовое описание дня недели
   string day=EnumToString(day_week);
//--- Преобразуем все полученные символы в нижний регистр и заменяем первую букву с маленькой на заглавную
   if(day.Lower())
      day.SetChar(0,ushort(day.GetChar(0)-0x20));
//--- Создаём текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header=StringFormat("Swap %s:",day);
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Объявляем свойство, которое необходимо запросить в SymbolInfoDouble()
   int prop=SYMBOL_SWAP_SUNDAY;
//--- В зависимости от дня недели указываем запрашиваемое свойство
   switch(day_week)
     {
      case MONDAY       : prop=SYMBOL_SWAP_MONDAY;    break;
      case TUESDAY      : prop=SYMBOL_SWAP_TUESDAY;   break;
      case WEDNESDAY    : prop=SYMBOL_SWAP_WEDNESDAY; break;
      case THURSDAY     : prop=SYMBOL_SWAP_THURSDAY;  break;
      case FRIDAY       : prop=SYMBOL_SWAP_FRIDAY;    break;
      case SATURDAY     : prop=SYMBOL_SWAP_SATURDAY;  break;
      default/*SUNDAY*/ : prop=SYMBOL_SWAP_SUNDAY;    break;
     }
//--- Получаем коэффициент по выбранному свойству и определяем строку его описания
   double swap_coeff=SymbolInfoDouble(symbol,(ENUM_SYMBOL_INFO_DOUBLE)prop);
   string coeff_descr=(swap_coeff==1 ? "single swap" : swap_coeff==3 ? "triple swap" : "no swap is charged");
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%.0f (%s)",indent,"",w,header,swap_coeff,coeff_descr);
   /* Пример вывода:
      Swap Sunday: 0 (no swap is charged)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал коэффициент начисления свопов                   |
//| по указанному дню недели                                         |
//+------------------------------------------------------------------+
void SymbolSwapByDayPrint(const string symbol,const ENUM_DAY_OF_WEEK day_week,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSwapByDay(symbol,day_week,header_width,indent));
  }


Начальная маржа (SYMBOL_MARGIN_INITIAL)

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

//+------------------------------------------------------------------+
//| Возвращает как строку начальную (инициирующую) маржу             |
//+------------------------------------------------------------------+
string SymbolMarginInitial(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin initial:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %s",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_MARGIN_INITIAL),SymbolInfoString(symbol,SYMBOL_CURRENCY_MARGIN));
   /* Пример вывода:
      Margin initial: 0.00 GBP
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал начальную (инициирующую) маржу                  |
//+------------------------------------------------------------------+
void SymbolMarginInitialPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginInitial(symbol,header_width,indent));
  }


Поддерживающая маржа (SYMBOL_MARGIN_MAINTENANCE)

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

//+------------------------------------------------------------------+
//| Возвращает как строку поддерживающую маржу по инструменту        |
//+------------------------------------------------------------------+
string SymbolMarginMaintenance(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin maintenance:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %s",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_MARGIN_MAINTENANCE),SymbolInfoString(symbol,SYMBOL_CURRENCY_MARGIN));
   /* Пример вывода:
      Margin maintenance: 0.00 GBP
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал поддерживающую маржу по инструменту             |
//+------------------------------------------------------------------+
void SymbolMarginMaintenancePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginMaintenance(symbol,header_width,indent));
  }


Объём сделок в текущую сессию (SYMBOL_SESSION_VOLUME)

Cуммарный объём сделок в текущую сессию.

//+------------------------------------------------------------------+
//| Возвращает как строку суммарный объём сделок в текущую сессию    |
//+------------------------------------------------------------------+
string SymbolSessionVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_VOLUME));
   /* Пример вывода:
      Session volume: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал суммарный объём сделок в текущую сессию         |
//+------------------------------------------------------------------+
void SymbolSessionVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionVolume(symbol,header_width,indent));
  }


Оборот в текущую сессию (SYMBOL_SESSION_TURNOVER)

Cуммарный оборот в текущую сессию.

//+------------------------------------------------------------------+
//| Возвращает как строку суммарный оборот в текущую сессию          |
//+------------------------------------------------------------------+
string SymbolSessionTurnover(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session turnover:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_TURNOVER));
   /* Пример вывода:
      Session turnover: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал суммарный оборот в текущую сессию               |
//+------------------------------------------------------------------+
void SymbolSessionTurnoverPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionTurnover(symbol,header_width,indent));
  }


Объём открытых позиций (SYMBOL_SESSION_INTEREST)

Cуммарный объём открытых позиций.

//+------------------------------------------------------------------+
//| Возвращает как строку суммарный объём открытых позиций           |
//+------------------------------------------------------------------+
string SymbolSessionInterest(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session interest:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_INTEREST));
   /* Пример вывода:
      Session interest: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал суммарный объём открытых позиций                |
//+------------------------------------------------------------------+
void SymbolSessionInterestPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionInterest(symbol,header_width,indent));
  }


Объём ордеров на покупку (SYMBOL_SESSION_BUY_ORDERS_VOLUME)

Общий объём ордеров на покупку в текущий момент.

//+------------------------------------------------------------------+
//| Возвращает как строку общий объём ордеров на покупку             |
//| в текущий момент                                                 |
//+------------------------------------------------------------------+
string SymbolSessionBuyOrdersVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Buy orders volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_BUY_ORDERS_VOLUME));
   /* Пример вывода:
      Session Buy orders volume: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал общий объём ордеров на покупку в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionBuyOrdersVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionBuyOrdersVolume(symbol,header_width,indent));
  }


Объём ордеров на продажу (SYMBOL_SESSION_SELL_ORDERS_VOLUME)

Общий объём ордеров на продажу в текущий момент.

//+------------------------------------------------------------------+
//| Возвращает как строку общий объём ордеров на продажу             |
//| в текущий момент                                                 |
//+------------------------------------------------------------------+
string SymbolSessionSellOrdersVolume(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Sell orders volume:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_SESSION_SELL_ORDERS_VOLUME));
   /* Пример вывода:
      Session Sell orders volume: 0.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал общий объём ордеров на продажу в текущий момент |
//+------------------------------------------------------------------+
void SymbolSessionSellOrdersVolumePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionSellOrdersVolume(symbol,header_width,indent));
  }


Цена открытия сессии (SYMBOL_SESSION_OPEN)

//+------------------------------------------------------------------+
//| Возвращает как строку цену открытия сессии                       |
//+------------------------------------------------------------------+
string SymbolSessionOpen(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Open:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_OPEN));
   /* Пример вывода:
      Session Open: 1.31314
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цену открытия сессии                            |
//+------------------------------------------------------------------+
void SymbolSessionOpenPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionOpen(symbol,header_width,indent));
  }


Цена закрытия сессии (SYMBOL_SESSION_CLOSE)

//+------------------------------------------------------------------+
//| Возвращает как строку цену закрытия сессии                       |
//+------------------------------------------------------------------+
string SymbolSessionClose(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session Close:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_CLOSE));
   /* Пример вывода:
      Session Close: 1.31349
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цену закрытия сессии                            |
//+------------------------------------------------------------------+
void SymbolSessionClosePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionClose(symbol,header_width,indent));
  }


Средневзвешенная цена сессии (SYMBOL_SESSION_AW)

//+------------------------------------------------------------------+
//| Возвращает как строку средневзвешенную цену сессии               |
//+------------------------------------------------------------------+
string SymbolSessionAW(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session AW:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_AW));
   /* Пример вывода:
      Session AW: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал средневзвешенную цену сессии                    |
//+------------------------------------------------------------------+
void SymbolSessionAWPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionAW(symbol,header_width,indent));
  }


Цена поставки на текущую сессию (SYMBOL_SESSION_PRICE_SETTLEMENT)

//+------------------------------------------------------------------+
//| Возвращает как строку цену поставки на текущую сессию            |
//+------------------------------------------------------------------+
string SymbolSessionPriceSettlement(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session price settlement:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_PRICE_SETTLEMENT));
   /* Пример вывода:
      Session price settlement: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал цену поставки на текущую сессию                 |
//+------------------------------------------------------------------+
void SymbolSessionPriceSettlementPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionPriceSettlement(symbol,header_width,indent));
  }


Минимальная цена на сессию (SYMBOL_SESSION_PRICE_LIMIT_MIN)

Минимально допустимое значение цены на сессию.

//+------------------------------------------------------------------+
//| Возвращает как строку минимально допустимое                      |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
string SymbolSessionPriceLimitMin(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session price limit min:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_PRICE_LIMIT_MIN));
   /* Пример вывода:
      Session price limit min: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал минимально допустимое                           |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
void SymbolSessionPriceLimitMinPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionPriceLimitMin(symbol,header_width,indent));
  }


Максимальная цена на сессию (SYMBOL_SESSION_PRICE_LIMIT_MAX)

Максимально допустимое значение цены на сессию.

//+------------------------------------------------------------------+
//| Возвращает как строку максимально допустимое                     |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
string SymbolSessionPriceLimitMax(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Session price limit max:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_SESSION_PRICE_LIMIT_MAX));
   /* Пример вывода:
      Session price limit max: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал максимально допустимое                          |
//| значение цены на сессию                                          |
//+------------------------------------------------------------------+
void SymbolSessionPriceLimitMaxPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSessionPriceLimitMax(symbol,header_width,indent));
  }


Размер контракта для одного лота перекрытых позиций (SYMBOL_MARGIN_HEDGED)

Размер контракта или маржи для одного лота перекрытых позиций (разнонаправленные позиции по одному символу). Существует два способа расчета маржи для перекрытых позиций. Способ расчета определяется брокером.
 
Базовый расчет:

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

Расчет по наибольшей позиции:

  • Значение SYMBOL_MARGIN_HEDGED не учитывается.
  • Вычисляется объем всех коротких и всех длинных позиций по инструменту.
  • Для каждой стороны рассчитывается средневзвешенная цена открытия, а также средневзвешенная цена конвертации в валюту депозита.
  • Далее по формулам, соответствующим типу инструмента (SYMBOL_TRADE_CALC_MODE), рассчитывается маржа для короткой и для длинной стороны.
  • В качестве итогового значения используется наибольшее.
//+------------------------------------------------------------------+
//| Возвращает как строку размер контракта или маржи                 |
//| для одного лота перекрытых позиций                               |
//+------------------------------------------------------------------+
string SymbolMarginHedged(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Margin hedged:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_MARGIN_HEDGED));
   /* Пример вывода:
      Margin hedged: 100000.00
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал размер контракта или маржи                      |
//| для одного лота перекрытых позиций                               |
//+------------------------------------------------------------------+
void SymbolMarginHedgedPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolMarginHedged(symbol,header_width,indent));
  }


Изменение текущей цены в процентах (SYMBOL_PRICE_CHANGE)

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

//+------------------------------------------------------------------+
//| Возвращает как строку изменение текущей цены относительно        |
//| конца предыдущего торгового дня, выраженное в процентах          |
//+------------------------------------------------------------------+
string SymbolPriceChange(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price change:";
   uint w=(header_width==0 ? header.Length()+1 : header_width-1);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%- .2f %%",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_PRICE_CHANGE));
   /* Пример вывода:
      Price change: -0.28 %
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал изменение текущей цены относительно             |
//| конца предыдущего торгового дня, выраженное в процентах          |
//+------------------------------------------------------------------+
void SymbolPriceChangePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceChange(symbol,header_width,indent));
  }


Волатильность цены в процентах (SYMBOL_PRICE_VOLATILITY)

//+------------------------------------------------------------------+
//| Возвращает как строку волатильность цены в процентах             |
//+------------------------------------------------------------------+
string SymbolPriceVolatility(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price volatility:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.2f %%",indent,"",w,header,SymbolInfoDouble(symbol,SYMBOL_PRICE_VOLATILITY));
   /* Пример вывода:
      Price volatility: 0.00 %
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал волатильность цены в процентах                  |
//+------------------------------------------------------------------+
void SymbolPriceVolatilityPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceVolatility(symbol,header_width,indent));
  }


Теоретическая цена опциона (SYMBOL_PRICE_THEORETICAL)

//+------------------------------------------------------------------+
//| Возвращает как строку теоретическую цену опциона                 |
//+------------------------------------------------------------------+
string SymbolPriceTheoretical(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price theoretical:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_THEORETICAL));
   /* Пример вывода:
      Price theoretical: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал теоретическую цену опциона                      |
//+------------------------------------------------------------------+
void SymbolPriceTheoreticalPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceTheoretical(symbol,header_width,indent));
  }


Дельта опциона/варранта (SYMBOL_PRICE_DELTA)

Дельта опциона/варранта. Показывает на сколько единиц изменится цена опциона при изменении цены базового актива на 1 единицу.

//+------------------------------------------------------------------+
//| Возвращает как строку дельту опциона/варранта                    |
//+------------------------------------------------------------------+
string SymbolPriceDelta(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price delta:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_DELTA));
   /* Пример вывода:
      Price delta: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал дельту опциона/варранта                         |
//+------------------------------------------------------------------+
void SymbolPriceDeltaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceDelta(symbol,header_width,indent));
  }


Тета опциона/варранта (SYMBOL_PRICE_THETA)

Тета опциона/варранта. Количество пунктов, которое будет терять цена опциона каждый день из-за временного распада, т.е. при приближении даты экспирации.

//+------------------------------------------------------------------+
//| Возвращает как строку тету опциона/варранта                      |
//+------------------------------------------------------------------+
string SymbolPriceTheta(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price theta:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_THETA));
   /* Пример вывода:
      Price theta: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал тету опциона/варранта                           |
//+------------------------------------------------------------------+
void SymbolPriceThetaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceTheta(symbol,header_width,indent));
  }


Гамма опциона/варранта (SYMBOL_PRICE_GAMMA)

Гамма опциона/варранта. Показывает скорость изменения дельты – насколько быстро или медленно меняется опционная премия.

//+------------------------------------------------------------------+
//| Возвращает как строку гамму опциона/варранта                     |
//+------------------------------------------------------------------+
string SymbolPriceGamma(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price gamma:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_GAMMA));
   /* Пример вывода:
      Price gamma: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал гамму опциона/варранта                          |
//+------------------------------------------------------------------+
void SymbolPriceGammaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceGamma(symbol,header_width,indent));
  }


Вега опциона/варранта (SYMBOL_PRICE_VEGA)

Вега опциона/варранта. Показывает количество пунктов, на которое изменится цена опциона при изменении волатильности на 1%.

//+------------------------------------------------------------------+
//| Возвращает как строку вегу опциона/варранта                      |
//+------------------------------------------------------------------+
string SymbolPriceVega(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price vega:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_VEGA));
   /* Пример вывода:
      Price vega: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал вегу опциона/варранта                           |
//+------------------------------------------------------------------+
void SymbolPriceVegaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceVega(symbol,header_width,indent));
  }


Ро опциона/варранта (SYMBOL_PRICE_RHO)

Ро опциона/варранта. Отражает чувствительность теоретической цены опциона к изменению процентной ставки на 1%.

//+------------------------------------------------------------------+
//| Возвращает как строку ро опциона/варранта                        |
//+------------------------------------------------------------------+
string SymbolPriceRho(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price rho:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_RHO));
   /* Пример вывода:
      Price rho: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал ро опциона/варранта                             |
//+------------------------------------------------------------------+
void SymbolPriceRhoPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceRho(symbol,header_width,indent));
  }


Омега опциона/варранта (SYMBOL_PRICE_OMEGA)

Омега опциона/варранта. Эластичность опциона – относительное процентное изменение цены опциона на процентное изменение цены базового актива.

//+------------------------------------------------------------------+
//| Возвращает как строку омегу опциона/варранта                     |
//+------------------------------------------------------------------+
string SymbolPriceOmega(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price omega:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_OMEGA));
   /* Пример вывода:
      Price omega: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал омегу опциона/варранта                          |
//+------------------------------------------------------------------+
void SymbolPriceOmegaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceOmega(symbol,header_width,indent));
  }


Чувствительность опциона/варранта (SYMBOL_PRICE_SENSITIVITY)

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

//+------------------------------------------------------------------+
//| Возвращает как строку чувствительность опциона/варранта          |
//+------------------------------------------------------------------+
string SymbolPriceSensitivity(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Price sensitivity:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем количество знаков после запятой
   int dg=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s%-.*f",indent,"",w,header,dg,SymbolInfoDouble(symbol,SYMBOL_PRICE_SENSITIVITY));
   /* Пример вывода:
      Price sensitivity: 0.00000
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал чувствительность опциона/варранта               |
//+------------------------------------------------------------------+
void SymbolPriceSensitivityPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPriceSensitivity(symbol,header_width,indent));
  }


Получение и вывод строковых свойств символа

Имя базового актива (SYMBOL_BASIS)

Имя базового актива для производного инструмента.

//+------------------------------------------------------------------+
//| Возвращает имя базового актива для производного инструмента      |
//+------------------------------------------------------------------+
string SymbolBasis(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Basis:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_BASIS);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Basis: '' (Not specified)
   */
  }

Если параметр не задан и возвращает пустую строку, то впишем пояснение (Not specified) рядом с пустым параметром.

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал имя базового актива для производного инструмента|
//+------------------------------------------------------------------+
void SymbolBasisPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBasis(symbol,header_width,indent));
  }


Категория или сектор инструмента (SYMBOL_CATEGORY)

Название категории или сектора, к которой принадлежит финансовый инструмент.

//+------------------------------------------------------------------+
//| Возвращает название категории или сектора финансового инструмента|
//+------------------------------------------------------------------+
string SymbolCategory(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Category:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CATEGORY);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Category: '' (Not specified)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал название категории или сектора                  |
//| финансового инструмента                                          |
//+------------------------------------------------------------------+
void SymbolCategoryPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCategory(symbol,header_width,indent));
  }


Страна финансового инструмента (SYMBOL_COUNTRY)

Страна, к которой отнесен финансовый инструмент.

//+------------------------------------------------------------------+
//| Возвращает страну, к которой отнесен финансовый инструмент       |
//+------------------------------------------------------------------+
string SymbolCountry(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Country:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_COUNTRY);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Country: '' (Not specified)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал страну, к которой отнесен финансовый инструмент |
//+------------------------------------------------------------------+
void SymbolCountryPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCountry(symbol,header_width,indent));
  }


Сектор экономики (SYMBOL_SECTOR_NAME)

Сектор экономики, к которому относится финансовый инструмент.

//+------------------------------------------------------------------+
//| Возвращает сектор экономики,                                     |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
string SymbolSectorName(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Sector name:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_SECTOR_NAME);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Sector name: 'Currency'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал сектор экономики,                               |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
void SymbolSectorNamePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolSectorName(symbol,header_width,indent));
  }


Отрасль экономики (SYMBOL_INDUSTRY_NAME)

Отрасль экономики или вид промышленности, к которой относится финансовый инструмент.

//+------------------------------------------------------------------+
//| Возвращает отрасль экономики или вид промышленности,             |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
string SymbolIndustryName(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Industry name:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_INDUSTRY_NAME);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Industry name: 'Undefined'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал отрасль экономики или вид промышленности,       |
//| к которому относится финансовый инструмент                       |
//+------------------------------------------------------------------+
void SymbolIndustryNamePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolIndustryName(symbol,header_width,indent));
  }


Базовая валюта (SYMBOL_CURRENCY_BASE)

Базовая валюта инструмента.

//+------------------------------------------------------------------+
//| Возвращает базовую валюту инструмента                            |
//+------------------------------------------------------------------+
string SymbolCurrencyBase(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Currency base:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CURRENCY_BASE);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Currency base: 'GBP'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал базовую валюту инструмента                      |
//+------------------------------------------------------------------+
void SymbolCurrencyBasePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCurrencyBase(symbol,header_width,indent));
  }


Валюта прибыли (SYMBOL_CURRENCY_PROFIT)

//+------------------------------------------------------------------+
//| Возвращает валюту прибыли                                        |
//+------------------------------------------------------------------+
string SymbolCurrencyProfit(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Currency profit:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CURRENCY_PROFIT);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Currency profit: 'USD'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал валюту прибыли                                  |
//+------------------------------------------------------------------+
void SymbolCurrencyProfitPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCurrencyProfit(symbol,header_width,indent));
  }


Валюта залоговых средств (SYMBOL_CURRENCY_MARGIN)

Валюта, в которой вычисляются залоговые средства.

//+------------------------------------------------------------------+
//| Возвращает валюту, в которой вычисляются залоговые средства      |
//+------------------------------------------------------------------+
string SymbolCurrencyMargin(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Currency margin:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_CURRENCY_MARGIN);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Currency margin: 'GBP'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал валюту, в которой вычисляются залоговые средства|
//+------------------------------------------------------------------+
void SymbolCurrencyMarginPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolCurrencyMargin(symbol,header_width,indent));
  }


Источник котировки (SYMBOL_BANK)

Источник текущей котировки.

//+------------------------------------------------------------------+
//| Возвращает источник текущей котировки                            |
//+------------------------------------------------------------------+
string SymbolBank(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Bank:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_BANK);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Bank: '' (Not specified)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал источник текущей котировки                      |
//+------------------------------------------------------------------+
void SymbolBankPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolBank(symbol,header_width,indent));
  }


Описание символа (SYMBOL_DESCRIPTION)

Строковое описание символа.

//+------------------------------------------------------------------+
//| Возвращает строковое описание символа                            |
//+------------------------------------------------------------------+
string SymbolDescription(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Description:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_DESCRIPTION);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Description: 'Pound Sterling vs US Dollar'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал строковое описание символа                      |
//+------------------------------------------------------------------+
void SymbolDescriptionPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolDescription(symbol,header_width,indent));
  }


Название биржи (SYMBOL_EXCHANGE)

Название биржи или торговой площадки, на которой торгуется символ.

//+------------------------------------------------------------------+
//| Возвращает название биржи или торговой площадки,                 |
//| на которой торгуется символ                                      |
//+------------------------------------------------------------------+
string SymbolExchange(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Exchange:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_EXCHANGE);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Exchange: '' (Not specified)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал название биржи или торговой площадки,           |
//| на которой торгуется символ                                      |
//+------------------------------------------------------------------+
void SymbolExchangePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolExchange(symbol,header_width,indent));
  }


Формула пользовательского символа (SYMBOL_FORMULA)

Формула для построения цены пользовательского символа. Если имя финансового инструмента, входящего в формулу, начинается с цифры или содержит спецсимвол (" ", ".", "-", "&", "#" и т.д.), то имя этого инструмента должно быть заключено в кавычки.

  • Синтетический символ: "@ESU19"/EURCAD
  • Календарный спред: "Si-9.13"-"Si-6.13"
  • Индекс евро: 34.38805726 * pow(EURUSD,0.3155) * pow(EURGBP,0.3056) * pow(EURJPY,0.1891) * pow(EURCHF,0.1113) * pow(EURSEK,0.0785)
//+------------------------------------------------------------------+
//| Возвращает формулу для построения цены пользовательского символа |
//+------------------------------------------------------------------+
string SymbolFormula(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Formula:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_FORMULA);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Formula: '' (Not specified)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал формулу для построения                          |
//| цены пользовательского символа                                   |
//+------------------------------------------------------------------+
void SymbolFormulaPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolFormula(symbol,header_width,indent));
  }


Имя в системе ISIN (SYMBOL_ISIN)

Имя торгового символа в системе международных идентификационных кодов ценных бумаг — ISIN (International Securities Identification Number). Международный идентификационный код ценной бумаги  — это 12-разрядный буквенно-цифровой код, однозначно идентифицирующий ценную бумагу. Наличие данного свойства символа определяется на стороне торгового сервера.

//+------------------------------------------------------------------+
//| Возвращает имя торгового символа в системе                       |
//| международных идентификационных кодов ценных бумаг               |
//+------------------------------------------------------------------+
string SymbolISIN(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="ISIN:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_ISIN);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      ISIN: '' (Not specified)
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал имя торгового символа в системе                 |
//| международных идентификационных кодов ценных бумаг               |
//+------------------------------------------------------------------+
void SymbolISINPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolISIN(symbol,header_width,indent));
  }


Адрес страницы в интернет (SYMBOL_PAGE)

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

//+------------------------------------------------------------------+
//| Возвращает адрес интернет страницы с информацией по символу      |
//+------------------------------------------------------------------+
string SymbolPage(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Page:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_PAGE);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Page: 'https://www.mql5.com/en/quotes/currencies/gbpusd'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал адрес интернет страницы с информацией по символу|
//+------------------------------------------------------------------+
void SymbolPagePrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPage(symbol,header_width,indent));
  }


Путь в дереве символов (SYMBOL_PATH)

//+------------------------------------------------------------------+
//| Возвращает путь в дереве символов                                |
//+------------------------------------------------------------------+
string SymbolPath(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Определяем текст заголовка и ширину поля заголовка
//--- Если ширина заголовка передана в функцию равной нулю, то шириной будет размер строки заголовка + 1
   string header="Path:";
   uint w=(header_width==0 ? header.Length()+1 : header_width);
//--- Получаем значение строкового параметра
   string param=SymbolInfoString(symbol,SYMBOL_PATH);
//--- Возвращаем значение свойства с заголовком с нужной шириной и отступом
   return StringFormat("%*s%-*s'%-s'%-s",indent,"",w,header,param,param=="" ? " (Not specified)" : "");
   /* Пример вывода:
      Path: 'Forex\GBPUSD'
   */
  }

Выводит в журнал значение, возвращаемое первой функцией: 

//+------------------------------------------------------------------+
//| Выводит в журнал путь в дереве символов                          |
//+------------------------------------------------------------------+
void SymbolPathPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Распечатываем в журнале значение свойства с заголовком с нужной шириной и отступом
   Print(SymbolPath(symbol,header_width,indent));
  }

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


Функция, распечатывающая в журнал все данные символа

На основе созданных функций, сделаем функцию, выводящую в журнал все свойства символа в порядке их следования в перечислениях ENUM_SYMBOL_INFO_INTEGER, ENUM_SYMBOL_INFO_DOUBLE и

ENUM_SYMBOL_INFO_STRING.

//+------------------------------------------------------------------+
//| Выводит в журнал все свойства символа                            |
//+------------------------------------------------------------------+
void SymbolInfoPrint(const string symbol,const uint header_width=0,const uint indent=0)
  {
//--- Выводим в журнал описания целочисленных свойств в порядке их расположения в ENUM_SYMBOL_INFO_INTEGER
   Print("SymbolInfoInteger properties:");
   SymbolSubscriptionDelayPrint(symbol,header_width,indent);
   SymbolSectorPrint(symbol,header_width,indent);
   SymbolIndustryPrint(symbol,header_width,indent);
   SymbolCustomPrint(symbol,header_width,indent);
   SymbolBackgroundColorPrint(symbol,header_width,indent);
   SymbolChartModePrint(symbol,header_width,indent);
   SymbolExistsPrint(symbol,header_width,indent);
   SymbolSelectedPrint(symbol,header_width,indent);
   SymbolVisiblePrint(symbol,header_width,indent);
   SymbolSessionDealsPrint(symbol,header_width,indent);
   SymbolSessionBuyOrdersPrint(symbol,header_width,indent);
   SymbolSessionSellOrdersPrint(symbol,header_width,indent);
   SymbolVolumePrint(symbol,header_width,indent);
   SymbolVolumeHighPrint(symbol,header_width,indent);
   SymbolVolumeLowPrint(symbol,header_width,indent);
   SymbolTimePrint(symbol,header_width,indent);
   SymbolTimeMSCPrint(symbol,header_width,indent);
   SymbolDigitsPrint(symbol,header_width,indent);
   SymbolSpreadPrint(symbol,header_width,indent);
   SymbolSpreadFloatPrint(symbol,header_width,indent);
   SymbolTicksBookDepthPrint(symbol,header_width,indent);
   SymbolTradeCalcModePrint(symbol,header_width,indent);
   SymbolTradeModePrint(symbol,header_width,indent);
   SymbolSymbolStartTimePrint(symbol,header_width,indent);
   SymbolSymbolExpirationTimePrint(symbol,header_width,indent);
   SymbolTradeStopsLevelPrint(symbol,header_width,indent);
   SymbolTradeFreezeLevelPrint(symbol,header_width,indent);
   SymbolTradeExeModePrint(symbol,header_width,indent);
   SymbolSwapModePrint(symbol,header_width,indent);
   SymbolSwapRollover3DaysPrint(symbol,header_width,indent);
   SymbolMarginHedgedUseLegPrint(symbol,header_width,indent);
   SymbolExpirationModePrint(symbol,header_width,indent);
   SymbolFillingModePrint(symbol,header_width,indent);
   SymbolOrderModePrint(symbol,header_width,indent);
   SymbolOrderGTCModePrint(symbol,header_width,indent);
   SymbolOptionModePrint(symbol,header_width,indent);
   SymbolOptionRightPrint(symbol,header_width,indent);

//--- Выводим в журнал описания вещественных свойств в порядке их расположения в ENUM_SYMBOL_INFO_DOUBLE
   Print("SymbolInfoDouble properties:");
   SymbolBidPrint(symbol,header_width,indent);
   SymbolBidHighPrint(symbol,header_width,indent);
   SymbolBidLowPrint(symbol,header_width,indent);
   SymbolAskPrint(symbol,header_width,indent);
   SymbolAskHighPrint(symbol,header_width,indent);
   SymbolAskLowPrint(symbol,header_width,indent);
   SymbolLastPrint(symbol,header_width,indent);
   SymbolLastHighPrint(symbol,header_width,indent);
   SymbolLastLowPrint(symbol,header_width,indent);
   SymbolVolumeRealPrint(symbol,header_width,indent);
   SymbolVolumeHighRealPrint(symbol,header_width,indent);
   SymbolVolumeLowRealPrint(symbol,header_width,indent);
   SymbolOptionStrikePrint(symbol,header_width,indent);
   SymbolPointPrint(symbol,header_width,indent);
   SymbolTradeTickValuePrint(symbol,header_width,indent);
   SymbolTradeTickValueProfitPrint(symbol,header_width,indent);
   SymbolTradeTickValueLossPrint(symbol,header_width,indent);
   SymbolTradeTickSizePrint(symbol,header_width,indent);
   SymbolTradeContractSizePrint(symbol,header_width,indent);
   SymbolTradeAccruedInterestPrint(symbol,header_width,indent);
   SymbolTradeFaceValuePrint(symbol,header_width,indent);
   SymbolTradeLiquidityRatePrint(symbol,header_width,indent);
   SymbolVolumeMinPrint(symbol,header_width,indent);
   SymbolVolumeMaxPrint(symbol,header_width,indent);
   SymbolVolumeStepPrint(symbol,header_width,indent);
   SymbolVolumeLimitPrint(symbol,header_width,indent);
   SymbolSwapLongPrint(symbol,header_width,indent);
   SymbolSwapShortPrint(symbol,header_width,indent);
   SymbolSwapByDayPrint(symbol,SUNDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,MONDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,TUESDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,WEDNESDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,THURSDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,FRIDAY,header_width,indent);
   SymbolSwapByDayPrint(symbol,SATURDAY,header_width,indent);
   SymbolMarginInitialPrint(symbol,header_width,indent);
   SymbolMarginMaintenancePrint(symbol,header_width,indent);
   SymbolSessionVolumePrint(symbol,header_width,indent);
   SymbolSessionTurnoverPrint(symbol,header_width,indent);
   SymbolSessionInterestPrint(symbol,header_width,indent);
   SymbolSessionBuyOrdersVolumePrint(symbol,header_width,indent);
   SymbolSessionSellOrdersVolumePrint(symbol,header_width,indent);
   SymbolSessionOpenPrint(symbol,header_width,indent);
   SymbolSessionClosePrint(symbol,header_width,indent);
   SymbolSessionAWPrint(symbol,header_width,indent);
   SymbolSessionPriceSettlementPrint(symbol,header_width,indent);
   SymbolSessionPriceLimitMinPrint(symbol,header_width,indent);
   SymbolSessionPriceLimitMaxPrint(symbol,header_width,indent);
   SymbolMarginHedgedPrint(symbol,header_width,indent);
   SymbolPriceChangePrint(symbol,header_width,indent);
   SymbolPriceVolatilityPrint(symbol,header_width,indent);
   SymbolPriceTheoreticalPrint(symbol,header_width,indent);
   SymbolPriceDeltaPrint(symbol,header_width,indent);
   SymbolPriceThetaPrint(symbol,header_width,indent);
   SymbolPriceGammaPrint(symbol,header_width,indent);
   SymbolPriceVegaPrint(symbol,header_width,indent);
   SymbolPriceRhoPrint(symbol,header_width,indent);
   SymbolPriceOmegaPrint(symbol,header_width,indent);
   SymbolPriceSensitivityPrint(symbol,header_width,indent);
   
//--- Выводим в журнал описания строковых свойств в порядке их расположения в ENUM_SYMBOL_INFO_STRING
   Print("SymbolInfoString properties:");
   SymbolBasisPrint(symbol,header_width,indent);
   SymbolCategoryPrint(symbol,header_width,indent);
   SymbolCountryPrint(symbol,header_width,indent);
   SymbolSectorNamePrint(symbol,header_width,indent);
   SymbolIndustryNamePrint(symbol,header_width,indent);
   SymbolCurrencyBasePrint(symbol,header_width,indent);
   SymbolCurrencyProfitPrint(symbol,header_width,indent);
   SymbolCurrencyMarginPrint(symbol,header_width,indent);
   SymbolBankPrint(symbol,header_width,indent);
   SymbolDescriptionPrint(symbol,header_width,indent);
   SymbolExchangePrint(symbol,header_width,indent);
   SymbolFormulaPrint(symbol,header_width,indent);
   SymbolISINPrint(symbol,header_width,indent);
   SymbolPagePrint(symbol,header_width,indent);
   SymbolPathPrint(symbol,header_width,indent);
  }
//+------------------------------------------------------------------+

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

Результат вызова функции из скрипта с шириной поля заголовка 28 символов и отступом 2 символа: 

void OnStart()
  {
//---
   SymbolInfoPrint(Symbol(),28,2);
   /* Пример вывода:
      SymbolInfoInteger properties:
        Subscription Delay:         No
        Sector:                     Currency
        Industry:                   Undefined
        Custom symbol:              No
        Background color:           Default
        Chart mode:                 Bid
        Exists:                     Yes
        Selected:                   Yes
        Visible:                    Yes
        Session deals:              0
        Session Buy orders:         0
        Session Sell orders:        0
        Volume:                     0
        Volume high:                0
        Volume low:                 0
        Time:                       2023.07.14 22:07:01
        Time msc:                   2023.07.14 22:07:01.706
        Digits:                     5
        Spread:                     5
        Spread float:               Yes
        Ticks book depth:           10
        Trade calculation mode:     Forex
        Trade mode:                 Full
        Start time:                 1970.01.01 00:00:00 (Not used)
        Expiration time:            1970.01.01 00:00:00 (Not used)
        Stops level:                0 (By Spread)
        Freeze level:               0 (Not used)
        Trade Execution mode:       Instant
        Swap mode:                  Points
        Swap Rollover 3 days:       Wednesday
        Margin hedged use leg:      No
        Expiration mode:            GTC|DAY|SPECIFIED
        Filling mode:               FOK|IOC|RETURN
        Order mode:                 MARKET|LIMIT|STOP|STOP_LIMIT|SL|TP|CLOSEBY
        Order GTC mode:             GTC
        Option mode:                European
        Option right:               Call
      SymbolInfoDouble properties:
        Bid:                        1.30979
        Bid High:                   1.31422
        Bid Low:                    1.30934
        Ask:                        1.30984
        Ask High:                   1.31427
        Ask Low:                    1.30938
        Last:                       0.00000
        Last High:                  0.00000
        Last Low:                   0.00000
        Volume real:                0.00
        Volume High real:           0.00
        Volume Low real:            0.00
        Option strike:              0.00000
        Point:                      0.00001
        Tick value:                 1.00000
        Tick value profit:          1.00000
        Tick value loss:            1.00000
        Tick size:                  0.00001
        Contract size:              100000.00 GBP
        Accrued interest:           0.00
        Face value:                 0.00
        Liquidity rate:             0.00
        Volume min:                 0.01
        Volume max:                 500.00
        Volume step:                0.01
        Volume limit:               0.00
        Swap long:                 -0.20
        Swap short:                -2.20
        Swap Sunday:                0 (no swap is charged)
        Swap Monday:                1 (single swap)
        Swap Tuesday:               1 (single swap)
        Swap Wednesday:             3 (triple swap)
        Swap Thursday:              1 (single swap)
        Swap Friday:                1 (single swap)
        Swap Saturday:              0 (no swap is charged)
        Margin initial:             0.00 GBP
        Margin maintenance:         0.00 GBP
        Session volume:             0.00
        Session turnover:           0.00
        Session interest:           0.00
        Session Buy orders volume:  0.00
        Session Sell orders volume: 0.00
        Session Open:               1.31314
        Session Close:              1.31349
        Session AW:                 0.00000
        Session price settlement:   0.00000
        Session price limit min:    0.00000
        Session price limit max:    0.00000
        Margin hedged:              100000.00
        Price change:              -0.28 %
        Price volatility:           0.00 %
        Price theoretical:          0.00000
        Price delta:                0.00000
        Price theta:                0.00000
        Price gamma:                0.00000
        Price vega:                 0.00000
        Price rho:                  0.00000
        Price omega:                0.00000
        Price sensitivity:          0.00000
      SymbolInfoString properties:
        Basis:                      '' (Not specified)
        Category:                   '' (Not specified)
        Country:                    '' (Not specified)
        Sector name:                'Currency'
        Industry name:              'Undefined'
        Currency base:              'GBP'
        Currency profit:            'USD'
        Currency margin:            'GBP'
        Bank:                       '' (Not specified)
        Description:                'Pound Sterling vs US Dollar'
        Exchange:                   '' (Not specified)
        Formula:                    '' (Not specified)
        ISIN:                       '' (Not specified)
        Page:                       'https://www.mql5.com/en/quotes/currencies/gbpusd'
        Path:                       'Forex\GBPUSD'
   */
  }

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

Это лишь пример того, как можно использовать функции, написанные выше. Их можно использовать "как есть" в своих программах, можно составить из них вывод некоторых групп свойств символов, а можно доработать под своё видение и потребности и использовать.


Заключение

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


Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.

Другие статьи автора

Перейти к обсуждению на форуме трейдеров
Представления частотной области временных рядов: Спектральная функция Представления частотной области временных рядов: Спектральная функция
В этой статье мы рассмотрим методы, связанные с анализом временных рядов в частотной области. Также будет уделено внимание пользе изучения спектральных функций временных рядов при построении прогностических моделей. Кроме того, мы обсудим некоторые многообещающие перспективы анализа временных рядов в частотной области с использованием дискретного преобразования Фурье (ДПФ).
Разработка системы репликации - Моделирование рынка (Часть 06): Первые улучшения (I) Разработка системы репликации - Моделирование рынка (Часть 06): Первые улучшения (I)
В этой статье мы приступим к стабилизации всей системы, иначе мы рискуем не выполнить следующие шаги.
Модель движения цены и ее основные положения. (Часть 3): Расчет оптимальных параметров биржевой игры Модель движения цены и ее основные положения. (Часть 3): Расчет оптимальных параметров биржевой игры
В рамках разработанного автором инженерного подхода, основанного на теории вероятности, находятся условия открытия прибыльной позиции и рассчитываются оптимальные – максимализирующие прибыль - значения тейкпрофита и стоплосса.
Разработка системы репликации - Моделирование рынка (Часть 05): Предварительный просмотр Разработка системы репликации - Моделирование рынка (Часть 05): Предварительный просмотр
Нам удалось разработать способ осуществления репликации рынка достаточно реалистичным и доступным образом. Теперь давайте продолжим наш проект и добавим данные для улучшения поведения репликации.