![StringFormat(). Обзор, готовые примеры использования](https://c.mql5.com/2/56/stringformatnw_600x314.jpg)
StringFormat(). Обзор, готовые примеры использования
Содержание
- Введение
- StringFormat(). Краткий обзор
- Форматирование строк
- Форматированный вывод свойств символа
- Получение и вывод целочисленных свойств символа
- Задержка данных
- Сектор экономики
- Вид промышленности
- Пользовательский символ
- Цвет фона в Market Watch
- Цена для построения баров
- Существование символа
- Выбран в Market Watch
- Отображается в Market Watch
- Количество сделок в текущей сессии
- Количество ордеров на покупку
- Количество ордеров на продажу
- Объем в последней сделке
- Максимальный объем за день
- Минимальный объем за день
- Время последней котировки
- Время последней котировки в мс
- Digits
- Спред
- Плавающий спред
- Количество заявок в стакане
- Способ вычисления стоимости контракта
- Тип исполнения ордеров
- Дата начала торгов
- Дата окончания торгов
- Stops Level
- Freeze Level
- Режим заключения сделок
- Модель расчета свопа
- День начисления тройного свопа
- Режим расчета хеджированной маржи
- Флаги режимов истечения ордеров
- Флаги режимов заливки ордеров
- Флаги разрешенных типов ордеров
- Срок действия StopLoss и TakeProfit ордеров
- Тип опциона
- Получение и вывод вещественных свойств символа
- Цена Bid
- Максимальный Bid за день
- Минимальный Bid за день
- Цена Ask
- Максимальный Ask за день
- Минимальный Ask за день
- Цена Last
- Максимальный Last за день
- Минимальный Last за день
- Объем последней сделки
- Максимальный объем за день
- Минимальный объем за день
- Цена исполнения опциона
- Point
- Стоимость тика
- Стоимость тика для прибыльной позиции
- Стоимость тика для убыточной позиции
- Минимальное изменение цены
- Размер торгового контракта
- Накопленный купонный доход
- Номинальная стоимость
- Коэффициент ликвидности
- Минимальный объем
- Максимальный объем
- Шаг изменения объема
- Максимальный объем позиции и ордеров в одном направлении
- Своп на покупку
- Своп на продажу
- Коэффициент начисления свопов
- Коэффициент начисления свопов с понедельника на вторник
- Коэффициент начисления свопов со вторника на среду
- Коэффициент начисления свопов со среды на четверг
- Коэффициент начисления свопов с четверга на пятницу
- Коэффициент начисления свопов с пятницы на субботу
- Коэффициент начисления свопов с субботы на воскресенье
- Начальная маржа
- Поддерживающая маржа
- Объём сделок в текущую сессию
- Оборот в текущую сессию
- Объём открытых позиций
- Объём ордеров на покупку
- Объём ордеров на продажу
- Цена открытия сессии
- Цена закрытия сессии
- Средневзвешенная цена сессии
- Цена поставки на текущую сессию
- Минимальная цена на сессию
- Максимальная цена на сессию
- Размер контракта для одного лота перекрытых позиций
- Изменение текущей цены в процентах
- Волатильность цены в процентах
- Теоретическая цена опциона
- Дельта опциона/варранта
- Тета опциона/варранта
- Гамма опциона/варранта
- Вега опциона/варранта
- Ро опциона/варранта
- Омега опциона/варранта
- Получение и вывод строковых свойств символа
- Имя базового актива
- Категория или сектор инструмента
- Страна финансового инструмента
- Сектор экономики
- Отрасль экономики
- Базовая валюта
- Валюта прибыли
- Валюта залоговых средств
- Источник котировки
- Описание символа
- Название биржи
- Формула пользовательского символа
- Имя в системе ISIN
- Адрес страницы в интернет
- Путь в дереве символов
- Функция, распечатывающая в журнал все данные символа
- Заключение
Введение
При выводе в журнал структурированной и отформатированной информации при помощи 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_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)
//+------------------------------------------------------------------+ //| Возвращает как строку право опциона | //+------------------------------------------------------------------+ 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 и
//+------------------------------------------------------------------+ //| Выводит в журнал все свойства символа | //+------------------------------------------------------------------+ 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.
![Представления частотной области временных рядов: Спектральная функция](https://c.mql5.com/2/54/power_spectrum4_avatar.png)
![Разработка системы репликации - Моделирование рынка (Часть 06): Первые улучшения (I)](https://c.mql5.com/2/53/replay-p6-avatar.png)
![Модель движения цены и ее основные положения. (Часть 3): Расчет оптимальных параметров биржевой игры](https://c.mql5.com/2/57/Avatar_The_price_movement_model_and_its_main_points_Part_3.png)
![Разработка системы репликации - Моделирование рынка (Часть 05): Предварительный просмотр](https://c.mql5.com/2/53/replay-p5-avatar.png)
![MQL5 - Язык торговых стратегий для клиентского терминала MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
- Бесплатные приложения для трейдинга
- 8 000+ сигналов для копирования
- Экономические новости для анализа финансовых рынков
Вы принимаете политику сайта и условия использования