Preise in der DoEasy-Bibliothek (Teil 60): Listen von Serien mit Symbol-Tickdaten

18 März 2021, 08:32
Artyom Trishkin
3
186

Inhalt


Konzept

Im vorigen Artikel habe ich begonnen, die Funktionalität für die Arbeit mit Tickdaten zu erstellen. Insbesondere habe ich die Klasse der Tickdaten-Objekte erstellt. Hier werde ich die Liste zum Speichern solcher Objekte erstellen. Solche Listen werden für jedes im Programm verwendete Symbol verfügbar sein. Standardmäßig ist die Größe der Tickdatenlisten für ein Symbol so gewählt, dass sie den aktuellen Tag abdecken. Natürlich wird es möglich sein, die Anzahl der Tage einzustellen, für die das Programm einen Satz von Tickdaten haben wird.

Warum brauchen wir nutzerdefinierte Tickdatenlisten, wenn MQL5 es erlaubt, sie jederzeit zu erhalten? Sie erlauben uns, die notwendigen Daten zu suchen, sowie Daten schnell und einfach zu vergleichen und zu erhalten. Diese Möglichkeit wird durch das eigentliche Konzept der Erstellung von Listen in der Bibliothek und der Arbeit mit ihnen geboten.

Ich werde die Listen, die für jedes vom Programm angewandte Symbol erstellt wurden, zu einer Kollektion von Tickdaten zusammenfassen, die es bequemer macht, mit Tickdaten eines beliebigen Symbols zu arbeiten und beliebige Analysen von Tickströmen verschiedener Symbole durchzuführen.


Verbesserung der Bibliothek der Klasse

Fügen wir zunächst neue Bibliotheksmeldungen in \MQL5\Include\DoEasy\Data.mqh ein. Indizes der neuen Nachrichten hinzufügen:

//--- CTick
   MSG_TICK_TEXT_TICK,                                // Tick
   MSG_TICK_TIME_MSC,                                 // Time of the last update of prices in milliseconds
   MSG_TICK_TIME,                                     // Time of the last update of prices
   MSG_TICK_VOLUME,                                   // Volume for the current Last price
   MSG_TICK_FLAGS,                                    // Flags
   MSG_TICK_VOLUME_REAL,                              // Volume for the current Last price with greater accuracy
   MSG_TICK_SPREAD,                                   // Spread
   MSG_LIB_TEXT_TICK_CHANGED_DATA,                    // Changed data on tick:
   MSG_LIB_TEXT_TICK_FLAG_BID,                        // Bid price change
   MSG_LIB_TEXT_TICK_FLAG_ASK,                        // Ask price change
   MSG_LIB_TEXT_TICK_FLAG_LAST,                       // Last deal price change
   MSG_LIB_TEXT_TICK_FLAG_VOLUME,                     // Volume change
   
//--- CTickSeries
   MSG_TICKSERIES_TEXT_TICKSERIES,                    // Tick series
   MSG_TICKSERIES_ERR_GET_TICK_DATA,                  // Failed to get tick data
   MSG_TICKSERIES_FAILED_CREATE_TICK_DATA_OBJ,        // Failed to create tick data object
   MSG_TICKSERIES_FAILED_ADD_TO_LIST,                 // Failed to add tick data object to list
   MSG_TICKSERIES_TEXT_IS_NOT_USE,                    // Tick series not used. Set the flag using SetAvailable()
   MSG_TICKSERIES_REQUIRED_HISTORY_DAYS,              // Requested number of days
   
  };
//+------------------------------------------------------------------+

und Textnachrichten, die den neu hinzugefügten Indizes entsprechen:

//--- CTick
   {"Тик","Tick"},
   {"Время последнего обновления цен в миллисекундах","Last price update time in milliseconds"},
   {"Время последнего обновления цен","Last price update time"},
   {"Объем для текущей цены Last","Volume for the current Last price"},
   {"Флаги","Flags"},
   {"Объем для текущей цены Last c повышенной точностью","Volume for the current \"Last\" price with increased accuracy"},
   {"Спред","Spread"},
   {"Изменённые данные на тике:","Changed data on a tick:"},
   {"Изменение цены Bid","Bid price change"},
   {"Изменение цены Ask","Ask price change"},
   {"Изменение цены последней сделки","Last price change"},
   {"Изменение объема","Volume change"},
   
//--- TickSeries
   {"Тиковая серия","Tick series"},
   {"Ошибка получения тиковых данных","Error getting tick data"},
   {"Не удалось создать объект тиковых данных","Failed to create tick data object"},
   {"Не удалось добавить объект тиковых данных в список","Failed to add tick data object to the list"},
   {"Тиковая серия не используется. Нужно установить флаг использования при помощи SetAvailable()","Tick series are not used. Need to set the use flag using SetAvailable()"},
   {"Запрошенное количество дней: ","Number of days requested: "},
   
  };
//+---------------------------------------------------------------------+

Die Tickdaten sollen standardmäßig für den aktuellen Tag gespeichert werden. In \MQL5\Include\DoEasy\Defines.mqh führen wir die neue Konstante (Makrosubstitution) ein, um die Anzahl der Tage festzulegen, für die die Bibliothek Ticks speichern soll:

//--- Timeseries parameters
#define SERIES_DEFAULT_BARS_COUNT      (1000)                     // Required default amount of timeseries data
#define PAUSE_FOR_SYNC_ATTEMPTS        (16)                       // Amount of pause milliseconds between synchronization attempts
#define ATTEMPTS_FOR_SYNC              (5)                        // Number of attempts to receive synchronization with the server
//--- Tick series parameters
#define TICKSERIES_DEFAULT_DAYS_COUNT  (1)                        // Required number of days for tick data in default series

Bei der erneuten Überprüfung des Codes der Zeitreihenklasse in \MQL5\Include\DoEasy\Objects\Series\SeriesDE.mqh ist mir ein Fehler aufgefallen — wenn ein erstelltes Balkenobjekt aus irgendeinem Grund nicht zur Liste hinzugefügt wird, wird es nicht entfernt. Dies kann zu einem Speicherleck führen. Lassen Sie uns daher eine Objektentfernung für den Fall hinzufügen, dass es nicht zur Liste hinzugefügt wurde:

//+------------------------------------------------------------------+
//| Create the timeseries list                                       |
//+------------------------------------------------------------------+
int CSeriesDE::Create(const uint required=0)
  {
//--- If the required history depth is not set for the list yet,
//--- display the appropriate message and return zero,
   if(this.m_amount==0)
     {
      ::Print(DFUN,this.m_symbol," ",TimeframeDescription(this.m_timeframe),": ",CMessage::Text(MSG_LIB_TEXT_BAR_TEXT_FIRS_SET_AMOUNT_DATA));
      return 0;
     }
//--- otherwise, if the passed 'required' value exceeds zero and is not equal to the one already set, 
//--- while being lower than the available bar number,
//--- set the new value of the required history depth for the list
   else if(required>0 && this.m_amount!=required && required<this.m_bars)
     {
      //--- If failed to set a new value, return zero
      if(!this.SetRequiredUsedData(required,0))
         return 0;
     }
//--- For the rates[] array we are to receive historical data to,
//--- set the flag of direction like in the timeseries,
//--- clear the bar object list and set the flag of sorting by bar index
   MqlRates rates[];
   ::ArraySetAsSeries(rates,true);
   this.m_list_series.Clear();
   this.m_list_series.Sort(SORT_BY_BAR_TIME);
   ::ResetLastError();
//--- Get historical data of the MqlRates structure to the rates[] array starting from the current bar in the amount of m_amount,
//--- if failed to get data, display the appropriate message and return zero
   int copied=::CopyRates(this.m_symbol,this.m_timeframe,0,(uint)this.m_amount,rates),err=ERR_SUCCESS;
   if(copied<1)
     {
      err=::GetLastError();
      ::Print(DFUN,CMessage::Text(MSG_LIB_TEXT_BAR_FAILED_GET_SERIES_DATA)," ",this.m_symbol," ",TimeframeDescription(this.m_timeframe),". ",
                   CMessage::Text(MSG_LIB_SYS_ERROR),": ",CMessage::Text(err),CMessage::Retcode(err));
      return 0;
     }
//--- Historical data is received in the rates[] array
//--- In the rates[] array loop,
   for(int i=0; i<copied; i++)
     {
      //--- create a new bar object out of the current MqlRates structure by the loop index
      ::ResetLastError();
      CBar* bar=new CBar(this.m_symbol,this.m_timeframe,rates[i]);
      if(bar==NULL)
        {
         ::Print
           (
            DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_BAR_OBJ)," ",this.Header()," ",::TimeToString(rates[i].time),". ",
            CMessage::Text(MSG_LIB_SYS_ERROR),": ",CMessage::Text(::GetLastError())
           );
         continue;
        }
      //--- If failed to add bar object to the list,
      //--- display the appropriate message with the error description in the journal
      //--- and remove the newly created object
      if(!this.m_list_series.Add(bar))
        {
         err=::GetLastError();
         ::Print(DFUN,CMessage::Text(MSG_LIB_TEXT_BAR_FAILED_ADD_TO_LIST)," ",bar.Header()," ",::TimeToString(rates[i].time),". ",
                      CMessage::Text(MSG_LIB_SYS_ERROR),": ",CMessage::Text(err),CMessage::Retcode(err));
         delete bar;
        }
     }
//--- Return the size of the created bar object list
   return this.m_list_series.Total();
  }
//+------------------------------------------------------------------+

Um Tick-Objekte aus der erstellten Liste suchen, sortieren und auswählen zu können, fügen wir die Methoden zum Arbeiten mit dieser Liste und mit Tick-Daten in \MQL5\Include\DoEasy\Services\Select.mqh ein.

Fügen wir die Datei der Tickdaten-Objektklasse ein:

//+------------------------------------------------------------------+
//|                                                       Select.mqh |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                             https://mql5.com/en/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://mql5.com/en/users/artmedia70"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include <Arrays\ArrayObj.mqh>
#include "..\Objects\Orders\Order.mqh"
#include "..\Objects\Events\Event.mqh"
#include "..\Objects\Accounts\Account.mqh"
#include "..\Objects\Symbols\Symbol.mqh"
#include "..\Objects\PendRequest\PendRequest.mqh"
#include "..\Objects\Series\SeriesDE.mqh"
#include "..\Objects\Indicators\Buffer.mqh"
#include "..\Objects\Indicators\IndicatorDE.mqh"
#include "..\Objects\Indicators\DataInd.mqh"
#include "..\Objects\Ticks\DataTick.mqh"
//+------------------------------------------------------------------+

Fügen wir am Ende des Klassenkörpers die Deklarationen von Methoden zur Arbeit mit Tickdaten hinzu:

//+------------------------------------------------------------------+
//| Methods of work with indicator data                              |
//+------------------------------------------------------------------+
   //--- Return the list of indicator data with one out of (1) integer, (2) real and (3) string properties meeting a specified criterion
   static CArrayObj *ByIndicatorDataProperty(CArrayObj *list_source,ENUM_IND_DATA_PROP_INTEGER property,long value,ENUM_COMPARER_TYPE mode);
   static CArrayObj *ByIndicatorDataProperty(CArrayObj *list_source,ENUM_IND_DATA_PROP_DOUBLE property,double value,ENUM_COMPARER_TYPE mode);
   static CArrayObj *ByIndicatorDataProperty(CArrayObj *list_source,ENUM_IND_DATA_PROP_STRING property,string value,ENUM_COMPARER_TYPE mode);
   //--- Return the indicator data index in the list with the maximum value of (1) integer, (2) real and (3) string property of data
   static int        FindIndDataMax(CArrayObj *list_source,ENUM_IND_DATA_PROP_INTEGER property);
   static int        FindIndDataMax(CArrayObj *list_source,ENUM_IND_DATA_PROP_DOUBLE property);
   static int        FindIndDataMax(CArrayObj *list_source,ENUM_IND_DATA_PROP_STRING property);
   //--- Return the indicator data index in the list with the minimum value of (1) integer, (2) real and (3) string property of data
   static int        FindIndDataMin(CArrayObj *list_source,ENUM_IND_DATA_PROP_INTEGER property);
   static int        FindIndDataMin(CArrayObj *list_source,ENUM_IND_DATA_PROP_DOUBLE property);
   static int        FindIndDataMin(CArrayObj *list_source,ENUM_IND_DATA_PROP_STRING property);
//+------------------------------------------------------------------+
//| Methods of working with tick data                                |
//+------------------------------------------------------------------+
   //--- Return the list of tick data with one out of (1) integer, (2) real and (3) string properties meeting a specified criterion
   static CArrayObj *ByTickDataProperty(CArrayObj *list_source,ENUM_TICK_PROP_INTEGER property,long value,ENUM_COMPARER_TYPE mode);
   static CArrayObj *ByTickDataProperty(CArrayObj *list_source,ENUM_TICK_PROP_DOUBLE property,double value,ENUM_COMPARER_TYPE mode);
   static CArrayObj *ByTickDataProperty(CArrayObj *list_source,ENUM_TICK_PROP_STRING property,string value,ENUM_COMPARER_TYPE mode);
   //--- Return the tick data index in the list with the maximum value of (1) integer, (2) real and (3) string property of data
   static int        FindTickDataMax(CArrayObj *list_source,ENUM_TICK_PROP_INTEGER property);
   static int        FindTickDataMax(CArrayObj *list_source,ENUM_TICK_PROP_DOUBLE property);
   static int        FindTickDataMax(CArrayObj *list_source,ENUM_TICK_PROP_STRING property);
   //--- Return the tick data index in the list with the minimum value of (1) integer, (2) real and (3) string property of data
   static int        FindTickDataMin(CArrayObj *list_source,ENUM_TICK_PROP_INTEGER property);
   static int        FindTickDataMin(CArrayObj *list_source,ENUM_TICK_PROP_DOUBLE property);
   static int        FindTickDataMin(CArrayObj *list_source,ENUM_TICK_PROP_STRING property);
//---
  };
//+------------------------------------------------------------------+

Implementieren wir die deklarierte Methoden außerhalb des Klassenkörpers:

//+------------------------------------------------------------------+
//| Methods of working with tick data lists                          |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Return the list of tick data with one of integer                 |
//| property meeting the specified criterion                         |
//+------------------------------------------------------------------+
CArrayObj *CSelect::ByTickDataProperty(CArrayObj *list_source,ENUM_TICK_PROP_INTEGER property,long value,ENUM_COMPARER_TYPE mode)
  {
   if(list_source==NULL) return NULL;
   CArrayObj *list=new CArrayObj();
   if(list==NULL) return NULL;
   list.FreeMode(false);
   ListStorage.Add(list);
   int total=list_source.Total();
   for(int i=0; i<total; i++)
     {
      CDataTick *obj=list_source.At(i);
      if(!obj.SupportProperty(property)) continue;
      long obj_prop=obj.GetProperty(property);
      if(CompareValues(obj_prop,value,mode)) list.Add(obj);
     }
   return list;
  }
//+------------------------------------------------------------------+
//| Return the list of tick data with one of real                    |
//| property meeting the specified criterion                         |
//+------------------------------------------------------------------+
CArrayObj *CSelect::ByTickDataProperty(CArrayObj *list_source,ENUM_TICK_PROP_DOUBLE property,double value,ENUM_COMPARER_TYPE mode)
  {
   if(list_source==NULL) return NULL;
   CArrayObj *list=new CArrayObj();
   if(list==NULL) return NULL;
   list.FreeMode(false);
   ListStorage.Add(list);
   for(int i=0; i<list_source.Total(); i++)
     {
      CDataTick *obj=list_source.At(i);
      if(!obj.SupportProperty(property)) continue;
      double obj_prop=obj.GetProperty(property);
      if(CompareValues(obj_prop,value,mode)) list.Add(obj);
     }
   return list;
  }
//+------------------------------------------------------------------+
//| Return the list of tick data with one of string                  |
//| property meeting the specified criterion                         |
//+------------------------------------------------------------------+
CArrayObj *CSelect::ByTickDataProperty(CArrayObj *list_source,ENUM_TICK_PROP_STRING property,string value,ENUM_COMPARER_TYPE mode)
  {
   if(list_source==NULL) return NULL;
   CArrayObj *list=new CArrayObj();
   if(list==NULL) return NULL;
   list.FreeMode(false);
   ListStorage.Add(list);
   for(int i=0; i<list_source.Total(); i++)
     {
      CDataTick *obj=list_source.At(i);
      if(!obj.SupportProperty(property)) continue;
      string obj_prop=obj.GetProperty(property);
      if(CompareValues(obj_prop,value,mode)) list.Add(obj);
     }
   return list;
  }
//+------------------------------------------------------------------+
//| Return the tick data in the list                                 |
//| with the maximum integer property value                          |
//+------------------------------------------------------------------+
int CSelect::FindTickDataMax(CArrayObj *list_source,ENUM_TICK_PROP_INTEGER property)
  {
   if(list_source==NULL) return WRONG_VALUE;
   int index=0;
   CDataTick *max_obj=NULL;
   int total=list_source.Total();
   if(total==0) return WRONG_VALUE;
   for(int i=1; i<total; i++)
     {
      CDataTick *obj=list_source.At(i);
      long obj1_prop=obj.GetProperty(property);
      max_obj=list_source.At(index);
      long obj2_prop=max_obj.GetProperty(property);
      if(CompareValues(obj1_prop,obj2_prop,MORE)) index=i;
     }
   return index;
  }
//+------------------------------------------------------------------+
//| Return the tick data in the list                                 |
//| with the maximum real property value                             |
//+------------------------------------------------------------------+
int CSelect::FindTickDataMax(CArrayObj *list_source,ENUM_TICK_PROP_DOUBLE property)
  {
   if(list_source==NULL) return WRONG_VALUE;
   int index=0;
   CDataTick *max_obj=NULL;
   int total=list_source.Total();
   if(total==0) return WRONG_VALUE;
   for(int i=1; i<total; i++)
     {
      CDataTick *obj=list_source.At(i);
      double obj1_prop=obj.GetProperty(property);
      max_obj=list_source.At(index);
      double obj2_prop=max_obj.GetProperty(property);
      if(CompareValues(obj1_prop,obj2_prop,MORE)) index=i;
     }
   return index;
  }
//+------------------------------------------------------------------+
//| Return the tick data in the list                                 |
//| with the maximum string property value                           |
//+------------------------------------------------------------------+
int CSelect::FindTickDataMax(CArrayObj *list_source,ENUM_TICK_PROP_STRING property)
  {
   if(list_source==NULL) return WRONG_VALUE;
   int index=0;
   CDataTick *max_obj=NULL;
   int total=list_source.Total();
   if(total==0) return WRONG_VALUE;
   for(int i=1; i<total; i++)
     {
      CDataTick *obj=list_source.At(i);
      string obj1_prop=obj.GetProperty(property);
      max_obj=list_source.At(index);
      string obj2_prop=max_obj.GetProperty(property);
      if(CompareValues(obj1_prop,obj2_prop,MORE)) index=i;
     }
   return index;
  }
//+------------------------------------------------------------------+
//| Return the tick data in the list                                 |
//| with the minimum integer property value                          |
//+------------------------------------------------------------------+
int CSelect::FindTickDataMin(CArrayObj* list_source,ENUM_TICK_PROP_INTEGER property)
  {
   int index=0;
   CDataTick *min_obj=NULL;
   int total=list_source.Total();
   if(total==0) return WRONG_VALUE;
   for(int i=1; i<total; i++)
     {
      CDataTick *obj=list_source.At(i);
      long obj1_prop=obj.GetProperty(property);
      min_obj=list_source.At(index);
      long obj2_prop=min_obj.GetProperty(property);
      if(CompareValues(obj1_prop,obj2_prop,LESS)) index=i;
     }
   return index;
  }
//+------------------------------------------------------------------+
//| Return the tick data in the list                                 |
//| with the minimum real property value                             |
//+------------------------------------------------------------------+
int CSelect::FindTickDataMin(CArrayObj* list_source,ENUM_TICK_PROP_DOUBLE property)
  {
   int index=0;
   CDataTick *min_obj=NULL;
   int total=list_source.Total();
   if(total== 0) return WRONG_VALUE;
   for(int i=1; i<total; i++)
     {
      CDataTick *obj=list_source.At(i);
      double obj1_prop=obj.GetProperty(property);
      min_obj=list_source.At(index);
      double obj2_prop=min_obj.GetProperty(property);
      if(CompareValues(obj1_prop,obj2_prop,LESS)) index=i;
     }
   return index;
  }
//+------------------------------------------------------------------+
//| Return the tick data in the list                                 |
//| with the minimum string property value                           |
//+------------------------------------------------------------------+
int CSelect::FindTickDataMin(CArrayObj* list_source,ENUM_TICK_PROP_STRING property)
  {
   int index=0;
   CDataTick *min_obj=NULL;
   int total=list_source.Total();
   if(total==0) return WRONG_VALUE;
   for(int i=1; i<total; i++)
     {
      CDataTick *obj=list_source.At(i);
      string obj1_prop=obj.GetProperty(property);
      min_obj=list_source.At(index);
      string obj2_prop=min_obj.GetProperty(property);
      if(CompareValues(obj1_prop,obj2_prop,LESS)) index=i;
     }
   return index;
  }
//+------------------------------------------------------------------+

Die Arbeit solcher Methoden habe ich schon mehrfach beschrieben. Mehr Infos dazu finden Sie in Teil 3.


Das Klassenobjekt der Tickdatenserien

Schreiben wir nun die Objektklasse Liste der Tickdaten. Genau wie alles andere in der Bibliothek sollte die Liste ein Array sein, das auf der Klasse des dynamischen Arrays von Zeigern auf die Instanzen der Klasse CObject und ihrer Nachkommen basiert.

Abhängig von der angegebenen Anzahl von Tagen, für die die Tick-Historie gespeichert werden soll, werde ich den Beginn des benötigten Tages berechnen. Alle vorhandenen Ticks sollen mit CopyTicksRange() ab diesem Tag in die Liste eingefügt werden. Im nächsten Artikel werde ich die Echtzeitaktualisierung dieser Listen so gestalten, dass immer die entsprechende Tickdatenbank in der Kollektion vorhanden ist.

Die Struktur der Objektklasse der Tickdatenliste ähnelt der Symbol-Zeitreihenlistenklasse. Der einzige Unterschied besteht darin, dass hier als minimale Datenspeichereinheit ein Tick-Objekt anstelle eines Balkenobjekts verwendet wird. Der Aufbau der Klasse soll ein Standard für die Bibliothek sein. Betrachten wir also ihren Körper im Ganzen und klären anschließend einige Details und Methoden:

//+------------------------------------------------------------------+
//|                                                   TickSeries.mqh |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                             https://mql5.com/en/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://mql5.com/en/users/artmedia70"
#property version   "1.00"
#property strict    // Necessary for mql4
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include "..\..\Services\Select.mqh"
#include "NewTickObj.mqh"
#include "DataTick.mqh"
//+------------------------------------------------------------------+
//| "Tick data series" class                                         |
//+------------------------------------------------------------------+
class CTickSeries : public CBaseObj
  {
private:
   string            m_symbol;                                          // Symbol
   uint              m_amount;                                          // Amount of applied tick series data
   uint              m_required;                                        // Required number of days for tick series data
   CArrayObj         m_list_ticks;                                      // List of tick data
   CNewTickObj       m_new_tick_obj;                                    // "New tick" object

public:
//--- Return (1) itself, (2) list of tick data and (3) "New tick" object of the tick series
   CTickSeries      *GetObject(void)                                    { return &this;               }
   CArrayObj        *GetList(void)                                      { return &m_list_ticks;       }
   CNewTickObj      *GetNewTickObj(void)                                { return &this.m_new_tick_obj;}

//--- Return the list of tick objects by selected (1) double, (2) integer and (3) string property fitting a compared condition
   CArrayObj        *GetList(ENUM_TICK_PROP_DOUBLE property,double value,ENUM_COMPARER_TYPE mode=EQUAL){ return CSelect::ByTickDataProperty(this.GetList(),property,value,mode); }
   CArrayObj        *GetList(ENUM_TICK_PROP_INTEGER property,long value,ENUM_COMPARER_TYPE mode=EQUAL) { return CSelect::ByTickDataProperty(this.GetList(),property,value,mode); }
   CArrayObj        *GetList(ENUM_TICK_PROP_STRING property,string value,ENUM_COMPARER_TYPE mode=EQUAL){ return CSelect::ByTickDataProperty(this.GetList(),property,value,mode); }
//--- Return the object of tick data by (1) index in the list, (2) time and (4) list size
   CDataTick        *GetTickByListIndex(const uint index);
   CDataTick        *GetTick(const datetime time); 
   CDataTick        *GetTick(const ulong time_msc); 
   int               DataTotal(void)                              const { return this.m_list_ticks.Total();       }

//--- The comparison method for searching identical tick series objects by a symbol
   virtual int       Compare(const CObject *node,const int mode=0) const 
                       {   
                        const CTickSeries *compared_obj=node;
                        return(this.Symbol()==compared_obj.Symbol() ? 0 : this.Symbol()>compared_obj.Symbol() ? 1 : -1);
                       } 
//--- Return the tick series name
   string            Header(void);
//--- Display (1) the tick series description and (2) the tick series short description in the journal
   void              Print(void);
   void              PrintShort(void);

//--- Constructors
                     CTickSeries(void){;}
                     CTickSeries(const string symbol,const uint required=0);

//+------------------------------------------------------------------+ 
//| Methods of working with objects and accessing their properties   |
//+------------------------------------------------------------------+
//--- Set (1) a symbol and (2) a number of used tick series data
   void              SetSymbol(const string symbol);                     
   void              SetRequiredUsedBars(const uint required=0);

//--- Return (1) symbol, (2) number of used, (3) requested tick data and (4) new tick flag
   string            Symbol(void)                                 const { return this.m_symbol;                   }
   ulong             AvailableUsedData(void)                      const { return this.m_amount;                   }
   ulong             RequiredUsedDays(void)                       const { return this.m_required;                 }
   bool              IsNewTick(void)                                    { return this.m_new_tick_obj.IsNewTick(); }

//--- Return (1) Bid, (2) Ask, (3) Last, (4) volume with increased accuracy,
//--- (5) spread, (6) volume, (7) tick flags, (8) time, (9) time in milliseconds by index in the list
   double            Bid(const uint index);
   double            Ask(const uint index);
   double            Last(const uint index);
   double            VolumeReal(const uint index);
   double            Spread(const uint index);
   long              Volume(const uint index);
   uint              Flags(const uint index);
   datetime          Time(const uint index);
   long              TimeMSC(const uint index);
   
//--- Return (1) Bid, (2) Ask, (3) Last, (4) volume with increased accuracy,
//--- (5) spread, (6) volume, (7) tick flags by tick time in milliseconds
   double            Bid(const ulong time_msc);
   double            Ask(const ulong time_msc);
   double            Last(const ulong time_msc);
   double            VolumeReal(const ulong time_msc);
   double            Spread(const ulong time_msc);
   long              Volume(const ulong time_msc);
   uint              Flags(const ulong time_msc);
   
//--- Return (1) Bid, (2) Ask, (3) Last, (4) volume with increased accuracy,
//--- (5) spread, (6) volume and (7) tick flags by tick time
   double            Bid(const datetime time);
   double            Ask(const datetime time);
   double            Last(const datetime time);
   double            VolumeReal(const datetime time);
   double            Spread(const datetime time);
   long              Volume(const datetime time);
   uint              Flags(const datetime time);

//--- (1) Create and (2) update the timeseries list
   int               Create(const uint required=0);
   void              Refresh(void);
  };
//+------------------------------------------------------------------+

Die zuvor vorbereitete Objektklassenlisten "New tick" und "Tick data" werden in die Klasse aufgenommen. Das Objekt "New tick" werden wir beim Aktualisieren der Tickdatenlisten im nächsten Artikel benötigen, während das Objekt "Tickdaten" die Klasse der Objekte ist, die in die Liste eingefügt werden sollen.

Alle notwendigen Klassenvariablen werden im privaten Bereich der Klasse deklariert. Diese Variablen sollen die Werte der Objektparameter, das Objekt der Objektlistenklasse (also die Tickliste selbst) und das Objekt "Neuer Tick", das im nächsten Artikel bei der Echtzeit-Listenaktualisierung benötigt wird, speichern.

Der 'public' Teil der Klasse enthält die für Bibliotheksobjekte üblichen Objektoperationsmethoden, die Methoden für den Zugriff auf die Eigenschaften des Tickdatenlistenobjekts, die Methoden für den vereinfachten Zugriff auf die Eigenschaften des angegebenen Tickdatenobjekts, das sich in der Liste befindet, und die Methoden zum Erstellen und Aktualisieren der Liste.

Betrachten wir nun die Objektmethoden.

Im parametrischen Klassenkonstruktor leeren wir die Liste, setzen das Flag der sortierten Liste nach Tickzeit in Millisekunden und die erforderliche Anzahl von Tagen, für die wir die Tickhistorie in der Liste haben müssen, mit der Methode SetRequiredUsedDays().

//+------------------------------------------------------------------+
//| Parametric constructor                                           |
//+------------------------------------------------------------------+
CTickSeries::CTickSeries(const string symbol,const uint required=0) : m_symbol(symbol)
  {
   this.m_list_ticks.Clear();
   this.m_list_ticks.Sort(SORT_BY_TICK_TIME_MSC);
   this.SetRequiredUsedDays(required);
  }
//+------------------------------------------------------------------+

Die Methode zum Setzen der Tickliste eines Symbols

//+------------------------------------------------------------------+
//| Set a symbol                                                     |
//+------------------------------------------------------------------+
void CTickSeries::SetSymbol(const string symbol)
  {
   if(this.m_symbol==symbol)
      return;
   this.m_symbol=(symbol==NULL || symbol=="" ? ::Symbol() : symbol);
  }
//+------------------------------------------------------------------+

Wenn ein an die Methode übergebenes Symbol bereits gesetzt ist, verlassen wir die Methode, ansonsten, wenn NULL oder ein Leerstring übergeben wird, wird das aktuelle Symbol verwendet. Andernfalls wird ein an die Methode übergebenes Symbol gesetzt.

Die Methode zum Setzen der Anzahl von Tagen, für die die Tickdaten benötigt werden:

//+------------------------------------------------------------------+
//| Set the number of required tick data                             |
//+------------------------------------------------------------------+
void CTickSeries::SetRequiredUsedDays(const uint required=0)
  {
   this.m_required=(required<1 ? TICKSERIES_DEFAULT_DAYS_COUNT : required);
  }
//+------------------------------------------------------------------+

Wenn Null oder weniger der Methode übergeben wird, verwenden wir die Standardanzahl von Tagen, sonst — die übergebene Anzahl von Tagen.

Die Methode gibt das Tickdaten-Objekt aus der Liste durch den Listenindex zurück:

//+------------------------------------------------------------------+
//| Return the tick object by its index in the list                  |
//+------------------------------------------------------------------+
CDataTick *CTickSeries::GetTickByListIndex(const uint index)
  {
   return this.m_list_ticks.At(index);
  }
//+------------------------------------------------------------------+

Geben Sie einfach das Objekt zurück, das sich in der Liste durch den an die Methode übergebenen Index befindet. Beachten Sie, dass die Methode NULL zurückgibt, wenn ein ungültiger Index angegeben wird oder die Liste leer ist.

Die Methode gibt das Tick-Objekt aus der Liste nach seiner Zeit zurück:

//+------------------------------------------------------------------+
//| Return the last tick object by its time                          |
//+------------------------------------------------------------------+
CDataTick *CTickSeries::GetTick(const datetime time)
  {
   CArrayObj *list=GetList(TICK_PROP_TIME,time,EQUAL);
   if(list==NULL) return NULL;
   return list.At(list.Total()-1);
  }
//+------------------------------------------------------------------+

Holt die Liste der Tick-Objekte mit der Zeit, die der an die Methode übergebenen entspricht, und gibt das letzte von ihnen zurück.
Verschiedene Ticks können die gleiche Zeit haben, daher wird der letzte von ihnen zurückgegeben.

Die Methode gibt das Tick-Objekt aus der Liste nach seiner Zeit in Millisekunden zurück:

//+------------------------------------------------------------------+
//| Return the last tick object by its time in milliseconds          |
//+------------------------------------------------------------------+
CDataTick *CTickSeries::GetTick(const ulong time_msc)
  {
   CArrayObj *list=GetList(TICK_PROP_TIME_MSC,time_msc,EQUAL);
   if(list==NULL) return NULL;
   return list.At(list.Total()-1);
  }
//+------------------------------------------------------------------+

Holt die Liste der Tick-Objekte mit ihrer Millisekundenzeit, die der an die Methode übergebenen entspricht, und gibt das letzte von ihnen zurück.
Wie in der gerade betrachteten Methode können verschiedene Ticks die gleiche Millisekundenzeit haben, daher wird der letzte von ihnen zurückgegeben, da er als der relevanteste angesehen wird.

Die nachfolgende Methoden zum Abrufen von Tick-Objekten sind identisch zueinander und haben drei Überladungen — Abrufen der Liste nach Index, nach Zeit und nach Zeit in Millisekunden. Betrachten wir diese drei Methoden zum Holen des Tick-Preises Bid und zeigen die Auflistung für andere identische Methoden.

Die Methode, die das Tick-Objekt Bid-Preis nach seinem Index in der Liste zurückgibt:

//+------------------------------------------------------------------+
//| Return tick's Bid by index in the list                           |
//+------------------------------------------------------------------+
double CTickSeries::Bid(const uint index)
  {
   CDataTick *tick=this.GetTickByListIndex(index);
   return(tick!=NULL ? tick.Bid() : 0);
  } 
//+------------------------------------------------------------------+

Holt das Objekt aus der Liste durch den an die Methode übergebenen Index und gibt entweder Bid oder 0 vom erhaltenen Objekt zurück (wenn das Objekt nicht geholt werden konnte).

Die Methode gibt den Bid-Preis des letzten Tick-Objekts in der Liste durch seine Zeit in Millisekunden zurück:

//+------------------------------------------------------------------+
//| Return tick's Bid by time in milliseconds                        |
//+------------------------------------------------------------------+
double CTickSeries::Bid(const ulong time_msc)
  {
   CDataTick *tick=this.GetTick(time_msc);
   return(tick!=NULL ? tick.Bid() : 0);
  } 
//+------------------------------------------------------------------+

Holt das letzte Objekt mit der an die Methode übergebenen Zeit in Millisekunden (die Holen-Methode wurde oben betrachtet) und gibt entweder Bid von dem erhaltenen Objekt zurück, oder 0 (wenn das Objekt nicht erhalten werden konnte).

Die Methode gibt den Bid-Preis des letzten Tick-Objekts nach seiner Zeit in der Liste zurück:

//+------------------------------------------------------------------+
//| Return tick's Bid by time                                        |
//+------------------------------------------------------------------+
double CTickSeries::Bid(const datetime time)
  {
   CDataTick *tick=this.GetTick(time);
   return(tick!=NULL ? tick.Bid() : 0);
  } 
//+------------------------------------------------------------------+

Beschafft das letzte Objekt um die an die Methode übergebene Zeit (die Beschaffungsmethode wurde oben betrachtet) und gibt entweder Bid vom erhaltenen Objekt oder 0 (wenn das Objekt nicht beschafft werden konnte) zurück.

Die übrigen Methoden zum Erhalten der Werte von Tick-Objekteigenschaften aus der Liste sind identisch mit den drei oben betrachteten Methoden. Überlassen wir deren Analyse einer unabhängigen Untersuchung:

//+------------------------------------------------------------------+
//| Return tick's Ask by index in the list                           |
//+------------------------------------------------------------------+

double CTickSeries::Ask(const uint index)
  {
   CDataTick *tick=this.GetTickByListIndex(index);
   return(tick!=NULL ? tick.Ask() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's Ask by time in milliseconds                        |
//+------------------------------------------------------------------+
double CTickSeries::Ask(const ulong time_msc)
  {
   CDataTick *tick=this.GetTick(time_msc);
   return(tick!=NULL ? tick.Ask() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's Ask by time                                        |
//+------------------------------------------------------------------+
double CTickSeries::Ask(const datetime time)
  {
   CDataTick *tick=this.GetTick(time);
   return(tick!=NULL ? tick.Ask() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's Last by index in the list                          |
//+------------------------------------------------------------------+
double CTickSeries::Last(const uint index)
  {
   CDataTick *tick=this.GetTickByListIndex(index);
   return(tick!=NULL ? tick.Last() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's Last by time in milliseconds                       |
//+------------------------------------------------------------------+
double CTickSeries::Last(const ulong time_msc)
  {
   CDataTick *tick=this.GetTick(time_msc);
   return(tick!=NULL ? tick.Last() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's Last by time                                       |
//+------------------------------------------------------------------+
double CTickSeries::Last(const datetime time)
  {
   CDataTick *tick=this.GetTick(time);
   return(tick!=NULL ? tick.Last() : 0);
  } 
//+-------------------------------------------------------------------------+
//| Return the volume with the increased tick accuracy by index in the list |
//+-------------------------------------------------------------------------+
double CTickSeries::VolumeReal(const uint index)
  {
   CDataTick *tick=this.GetTickByListIndex(index);
   return(tick!=NULL ? tick.VolumeReal() : 0);
  } 
//+--------------------------------------------------------------------------+
//|Return the volume with the increased tick accuracy by time in milliseconds|
//+--------------------------------------------------------------------------+
double CTickSeries::VolumeReal(const ulong time_msc)
  {
   CDataTick *tick=this.GetTick(time_msc);
   return(tick!=NULL ? tick.VolumeReal() : 0);
  } 
//+------------------------------------------------------------------+
//| Return the volume with the increased tick accuracy by time       |
//+------------------------------------------------------------------+
double CTickSeries::VolumeReal(const datetime time)
  {
   CDataTick *tick=this.GetTick(time);
   return(tick!=NULL ? tick.VolumeReal() : 0);
  } 
//+------------------------------------------------------------------+
//| Return the tick spread by index in the list                      |
//+------------------------------------------------------------------+
double CTickSeries::Spread(const uint index)
  {
   CDataTick *tick=this.GetTickByListIndex(index);
   return(tick!=NULL ? tick.Spread() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's spread by time in milliseconds                     |
//+------------------------------------------------------------------+
double CTickSeries::Spread(const ulong time_msc)
  {
   CDataTick *tick=this.GetTick(time_msc);
   return(tick!=NULL ? tick.Spread() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's spread by time                                     |
//+------------------------------------------------------------------+
double CTickSeries::Spread(const datetime time)
  {
   CDataTick *tick=this.GetTick(time);
   return(tick!=NULL ? tick.Spread() : 0);
  } 
//+------------------------------------------------------------------+
//| Return the tick volume by index in the list                      |
//+------------------------------------------------------------------+
long CTickSeries::Volume(const uint index)
  {
   CDataTick *tick=this.GetTickByListIndex(index);
   return(tick!=NULL ? tick.Volume() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's volume by time in milliseconds                     |
//+------------------------------------------------------------------+
long CTickSeries::Volume(const ulong time_msc)
  {
   CDataTick *tick=this.GetTick(time_msc);
   return(tick!=NULL ? tick.Volume() : 0);
  } 
//+------------------------------------------------------------------+
//| Return tick's volume by time                                     |
//+------------------------------------------------------------------+
long CTickSeries::Volume(const datetime time)
  {
   CDataTick *tick=this.GetTick(time);
   return(tick!=NULL ? tick.Volume() : 0);
  } 
//+------------------------------------------------------------------+
//| Return the tick flags by index in the list                       |
//+------------------------------------------------------------------+
uint CTickSeries::Flags(const uint index)
  {
   CDataTick *tick=this.GetTickByListIndex(index);
   return(tick!=NULL ? tick.Flags() : 0);
  } 
//+------------------------------------------------------------------+
//| Return the tick flags by time in milliseconds                    |
//+------------------------------------------------------------------+
uint CTickSeries::Flags(const ulong time_msc)
  {
   CDataTick *tick=this.GetTick(time_msc);
   return(tick!=NULL ? tick.Flags() : 0);
  } 
//+------------------------------------------------------------------+
//| Return the tick flags by time                                    |
//+------------------------------------------------------------------+
uint CTickSeries::Flags(const datetime time)
  {
   CDataTick *tick=this.GetTick(time);
   return(tick!=NULL ? tick.Flags() : 0);
  } 
//+------------------------------------------------------------------+

Jede der Methoden wird durch drei identische überladene Methoden repräsentiert, die es ermöglichen, das Tick-Objekt nach seinem Index in der Liste und nach der Zeit sowohl im Datumsformat als auch in Millisekunden zu erhalten.

Die Methode gibt den Text-Namen der Tick-Serie zurück:

//+------------------------------------------------------------------+
//| Return the tick series name                                      |
//+------------------------------------------------------------------+
string CTickSeries::Header(void)
  {
   return CMessage::Text(MSG_TICKSERIES_TEXT_TICKSERIES)+" \""+this.m_symbol+"\"";
  }
//+------------------------------------------------------------------+

Rückgabe der Zeichenkette im Format

Tickseries "symbol name"

Zum Beispiel:

Tick series "EURUSD"

Die Methode, die die vollständige Beschreibung der Tick-Reihe im Journal anzeigt:

//+------------------------------------------------------------------+
//| Display the tick series description in the journal               |
//+------------------------------------------------------------------+
void CTickSeries::Print(void)
  {
   string txt=
     (
      CMessage::Text(MSG_TICKSERIES_REQUIRED_HISTORY_DAYS)+(string)this.RequiredUsedDays()+", "+
      CMessage::Text(MSG_LIB_TEXT_TS_AMOUNT_HISTORY_DATA)+(string)this.DataTotal()
     );
   ::Print(this.Header(),": ",txt);
  }
//+------------------------------------------------------------------+

Die Methode erzeugt die Zeichenkette mit der Beschreibung der Anzahl der Tage, für die die Ticks in der Serie gespeichert sind, und die Anzahl der Ticks, die tatsächlich in der Liste gespeichert sind.
Die Überschrift der Tick-Serie und der erzeugte String werden anschließend angezeigt. Zum Beispiel:

Tick series "EURUSD": Requested number of days: 1, Historical data created: 256714

Die Methode, die die Kurzbeschreibung der Tick-Serie im Journal anzeigt:

//+------------------------------------------------------------------+
//| Display the brief tick series description in the journal         |
//+------------------------------------------------------------------+
void CTickSeries::PrintShort(void)
  {
   ::Print(this.Header());
  }
//+------------------------------------------------------------------+

Schreiben des Text-Namens der Tick-Serie im Journal.

Die Methode zum Erstellen der Tick-Reihe:

//+------------------------------------------------------------------+
//| Create the series list of tick data                              |
//+------------------------------------------------------------------+
int CTickSeries::Create(const uint required=0)
  {
//--- If the tick series is not used, inform of that and exit
   if(!this.m_available)
     {
      ::Print(DFUN,this.m_symbol,": ",CMessage::Text(MSG_TICKSERIES_TEXT_IS_NOT_USE));
      return false;
     }
//--- Declare the ticks[] array we are to receive historical data to,
//--- clear the list of tick data objects and set the flag of sorting by time in milliseconds
   MqlTick ticks_array[];
   this.m_list_ticks.Clear();
   this.m_list_ticks.Sort(SORT_BY_TICK_TIME_MSC);
   ::ResetLastError();
   int err=ERR_SUCCESS;
//--- Calculate the day start time in milliseconds the ticks should be copied from
   MqlDateTime date_str={0};
   datetime date=::iTime(m_symbol,PERIOD_D1,this.m_required);
   ::TimeToStruct(date,date_str);
   date_str.hour=date_str.min=date_str.sec=0;
   date=::StructToTime(date_str);
   long date_from=(long)date*1000;
   if(date_from<1) date_from=1;
//--- Get historical data of the MqlTick structure to the tick[] array
//--- from the calculated date to the current time and save the obtained number in m_amount.
//--- If failed to get data, display the appropriate message and return zero
   this.m_amount=::CopyTicksRange(m_symbol,ticks_array,COPY_TICKS_ALL,date_from);
   if(this.m_amount<1)
     {
      err=::GetLastError();
      ::Print(DFUN,CMessage::Text(MSG_TICKSERIES_ERR_GET_TICK_DATA),": ",CMessage::Text(err),CMessage::Retcode(err));
      return 0;
     }
//--- Historical data is received in the rates[] array
//--- In the ticks[] array loop
   for(int i=0; i<(int)this.m_amount; i++)
     {
      //--- create a new object of tick data out of the current MqlTick structure data from the ticks[] array by the loop index
      ::ResetLastError();
      CDataTick* tick=new CDataTick(this.m_symbol,ticks_array[i]);
      if(tick==NULL)
        {
         ::Print
           (
            DFUN,CMessage::Text(MSG_TICKSERIES_FAILED_CREATE_TICK_DATA_OBJ)," ",this.Header()," ",::TimeMSCtoString(ticks_array[i].time_msc),". ",
            CMessage::Text(MSG_LIB_SYS_ERROR),": ",CMessage::Text(::GetLastError())
           );
         continue;
        }
      //--- If failed to add a new tick data object to the list
      //--- display the appropriate message with the error description in the journal
      //--- and remove the newly created object
      if(!this.m_list_ticks.Add(tick))
        {
         err=::GetLastError();
         ::Print(DFUN,CMessage::Text(MSG_TICKSERIES_FAILED_ADD_TO_LIST)," ",tick.Header()," ",
                      CMessage::Text(MSG_LIB_SYS_ERROR),": ",CMessage::Text(err),CMessage::Retcode(err));
         delete tick;
        }
     }
//--- Return the size of the created bar object list
   return this.m_list_ticks.Total();
  }
//+------------------------------------------------------------------+

Die Funktionsweise der Methode ist im Codelisting detailliert beschrieben. Kurzgefasst:
Berechnen der die Startzeit des Tages, aus dem wir die Ticks kopieren sollen und Anforderung der Ticks ab dem berechneten Datum aus dem Array. Wenn die Ticks erfolgreich berechnet wurden, holen wir uns in einer Schleife durch das erhaltene Tick-Array den nächsten Tick im Format der Struktur MqlTick. Wir verwenden das Array, um ein neues Tick-Objekt zu erstellen, das im Falle seiner erfolgreichen Erstellung in die Liste eingefügt wird. Nach dem Ende der Schleife geben wir die Anzahl der Ticks zurück, die in der Tick-Datenliste platziert wurden.

Damit ist die Erstellung der Tick-Datenliste abgeschlossen.


Test der Listenerstellung und des Datenempfangs

Zu Testzwecken erstellen wir einfach während des Programmstarts eine Liste von Tick-Objekten für das aktuelle Symbol für den aktuellen Tag. In der erhaltenen Liste suchen wir den Tick mit dem höchsten Ask- und dem niedrigsten Bid-Preis und lassen Sie sich die Daten der gefundenen Tick-Objekte im Journal anzeigen. Dafür nehmen wir den EA aus dem vorherigen Artikel und speichern Sie ihn in \MQL5\Experts\TestDoEasy\Part60\ as TestDoEasyPart60.mq5.

Da es sich hierbei lediglich um einen Test der Tick-Datenliste handelt und nicht direkt aus der Bibliothek heraus zugegriffen werden kann, binden wir die Objektklasse Tick-Datenliste in die EA-Datei ein:

//|                                             TestDoEasyPart60.mq5 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                             https://mql5.com/en/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://mql5.com/en/users/artmedia70"
#property version   "1.00"
//--- includes
#include <DoEasy\Engine.mqh>
#include <DoEasy\Objects\Ticks\TickSeries.mqh>
//--- enums

Im Bereich der globalen Variablen des Programms deklarieren wir das Objekt der Tickdatenliste:

//--- global variables
CEngine        engine;
SDataButt      butt_data[TOTAL_BUTT];
string         prefix;
double         lot;
double         withdrawal=(InpWithdrawal<0.1 ? 0.1 : InpWithdrawal);
ushort         magic_number;
uint           stoploss;
uint           takeprofit;
uint           distance_pending;
uint           distance_stoplimit;
uint           distance_pending_request;
uint           bars_delay_pending_request;
uint           slippage;
bool           trailing_on;
bool           pressed_pending_buy;
bool           pressed_pending_buy_limit;
bool           pressed_pending_buy_stop;
bool           pressed_pending_buy_stoplimit;
bool           pressed_pending_close_buy;
bool           pressed_pending_close_buy2;
bool           pressed_pending_close_buy_by_sell;
bool           pressed_pending_sell;
bool           pressed_pending_sell_limit;
bool           pressed_pending_sell_stop;
bool           pressed_pending_sell_stoplimit;
bool           pressed_pending_close_sell;
bool           pressed_pending_close_sell2;
bool           pressed_pending_close_sell_by_buy;
bool           pressed_pending_delete_all;
bool           pressed_pending_close_all;
bool           pressed_pending_sl;
bool           pressed_pending_tp;
double         trailing_stop;
double         trailing_step;
uint           trailing_start;
uint           stoploss_to_modify;
uint           takeprofit_to_modify;
int            used_symbols_mode;
string         array_used_symbols[];
string         array_used_periods[];
bool           testing;
uchar          group1;
uchar          group2;
double         g_point;
int            g_digits;

//--- "New tick" object
CNewTickObj    check_tick;
//--- Object of the current symbol tick series data
CTickSeries    tick_series;
//+------------------------------------------------------------------+

In OnTick() entfernen wir den Codeblock, um mit Tick-Datenobjekten zu arbeiten. Er ist seit dem vorherigen Artikel hier belassen worden. Wir werden hier keine Objekte erzeugen:

//--- Create a temporary list for storing “Tick data” objects,
//--- a variable for obtaining tick data and
//--- a variable for calculating incoming ticks
   static int tick_count=0;
   CArrayObj list;
   MqlTick tick_struct;
//--- Check a new tick on the current symbol
   if(check_tick.IsNewTick())
     {
      //--- If failed to get the price - exit
      if(!SymbolInfoTick(Symbol(),tick_struct))
         return;
      //--- Create a new tick data object
      CDataTick *tick_obj=new CDataTick(Symbol(),tick_struct);
      if(tick_obj==NULL)
         return;
      //--- Increase tick counter (simply to display on the screen, no other purpose is provided)
      tick_count++;
      //--- Limit the number of ticks in the counting as one hundred thousand (again, no purpose is provided)
      if(tick_count>100000) tick_count=1;
      //--- In the comment on the chart display the tick number and its short description
      Comment("--- #",IntegerToString(tick_count,5,'0'),": ",tick_obj.Header());
      //--- If this is the first tick (which follows the first launch of EA) display its full description in the journal
      if(tick_count==1)
         tick_obj.Print();
      //--- Remove if failed to put the created tick data object in the list
      if(!list.Add(tick_obj))
         delete tick_obj;
     }

OnTick() wird also wie folgt aussehen:

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Handle the NewTick event in the library
   engine.OnTick(rates_data);

//--- If working in the tester
   if(MQLInfoInteger(MQL_TESTER))
     {
      engine.OnTimer(rates_data);   // Working in the timer
      PressButtonsControl();        // Button pressing control
      engine.EventsHandling();      // Working with events
     }

//--- If the trailing flag is set
   if(trailing_on)
     {
      TrailingPositions();          // Trailing positions
      TrailingOrders();             // Trailing pending orders
     }
  }
//+------------------------------------------------------------------+

Die Liste soll im OnInit() innerhalb der DoEasy-Bibliotheksinitialisierungsfunktion erstellt werden, also im Codeblock:

//+------------------------------------------------------------------+
//| Initializing DoEasy library                                      |
//+------------------------------------------------------------------+
void OnInitDoEasy()
  {
//--- Check if working with the full list is selected
   used_symbols_mode=InpModeUsedSymbols;
   if((ENUM_SYMBOLS_MODE)used_symbols_mode==SYMBOLS_MODE_ALL)
     {
      int total=SymbolsTotal(false);
      string ru_n="\nКоличество символов на сервере "+(string)total+".\nМаксимальное количество: "+(string)SYMBOLS_COMMON_TOTAL+" символов.";
      string en_n="\nNumber of symbols on server "+(string)total+".\nMaximum number: "+(string)SYMBOLS_COMMON_TOTAL+" symbols.";
      string caption=TextByLanguage("Внимание!","Attention!");
      string ru="Выбран режим работы с полным списком.\nВ этом режиме первичная подготовка списков коллекций символов и таймсерий может занять длительное время."+ru_n+"\nПродолжить?\n\"Нет\" - работа с текущим символом \""+Symbol()+"\"";
      string en="Full list mode selected.\nIn this mode, the initial preparation of lists of symbol collections and timeseries can take a long time."+en_n+"\nContinue?\n\"No\" - working with the current symbol \""+Symbol()+"\"";
      string message=TextByLanguage(ru,en);
      int flags=(MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2);
      int mb_res=MessageBox(message,caption,flags);
      switch(mb_res)
        {
         case IDNO : 
           used_symbols_mode=SYMBOLS_MODE_CURRENT; 
           break;
         default:
           break;
        }
     }
//--- Set the counter start point to measure the approximate library initialization time
   ulong begin=GetTickCount();
   Print(TextByLanguage("--- Инициализация библиотеки \"DoEasy\" ---","--- Initializing the \"DoEasy\" library ---"));
//--- Fill in the array of used symbols
   CreateUsedSymbolsArray((ENUM_SYMBOLS_MODE)used_symbols_mode,InpUsedSymbols,array_used_symbols);
//--- Set the type of the used symbol list in the symbol collection and fill in the list of symbol timeseries
   engine.SetUsedSymbols(array_used_symbols);
//--- Displaying the selected mode of working with the symbol object collection in the journal
   string num=
     (
      used_symbols_mode==SYMBOLS_MODE_CURRENT ? ": \""+Symbol()+"\"" : 
      TextByLanguage(". Количество используемых символов: ",". The number of symbols used: ")+(string)engine.GetSymbolsCollectionTotal()
     );
   Print(engine.ModeSymbolsListDescription(),num);
//--- Implement displaying the list of used symbols only for MQL5 - MQL4 has no ArrayPrint() function
#ifdef __MQL5__
   if(InpModeUsedSymbols!=SYMBOLS_MODE_CURRENT)
     {
      string array_symbols[];
      CArrayObj* list_symbols=engine.GetListAllUsedSymbols();
      for(int i=0;i<list_symbols.Total();i++)
        {
         CSymbol *symbol=list_symbols.At(i);
         if(symbol==NULL)
            continue;
         ArrayResize(array_symbols,ArraySize(array_symbols)+1,SYMBOLS_COMMON_TOTAL);
         array_symbols[ArraySize(array_symbols)-1]=symbol.Name();
        }
      ArrayPrint(array_symbols);
     }
#endif   
//--- Set used timeframes
   CreateUsedTimeframesArray(InpModeUsedTFs,InpUsedTFs,array_used_periods);
//--- Display the selected mode of working with the timeseries object collection
   string mode=
     (
      InpModeUsedTFs==TIMEFRAMES_MODE_CURRENT   ? 
         TextByLanguage("Работа только с текущим таймфреймом: ","Work only with the current Period: ")+TimeframeDescription((ENUM_TIMEFRAMES)Period())   :
      InpModeUsedTFs==TIMEFRAMES_MODE_LIST      ? 
         TextByLanguage("Работа с заданным списком таймфреймов:","Work with a predefined list of Periods:")                                              :
      TextByLanguage("Работа с полным списком таймфреймов:","Work with the full list of all Periods:")
     );
   Print(mode);
//--- Implement displaying the list of used timeframes only for MQL5 - MQL4 has no ArrayPrint() function
#ifdef __MQL5__
   if(InpModeUsedTFs!=TIMEFRAMES_MODE_CURRENT)
      ArrayPrint(array_used_periods);
#endif 
//--- Create timeseries of all used symbols
   engine.SeriesCreateAll(array_used_periods);

//--- Check created timeseries - display descriptions of all created timeseries in the journal
//--- (true - only created ones, false - created and declared ones)
   engine.GetTimeSeriesCollection().PrintShort(false); // Short descriptions
   //engine.GetTimeSeriesCollection().Print(true);      // Full descriptions

//--- Code block for checking the tick list creation and working with it
   Print("");
//--- Since the tick series object is created with the default constructor,
//--- set a symbol, usage flag and the number of days (the default is 1) to copy the ticks
//--- Create the tick series and printed data in the journal
   tick_series.SetSymbol(Symbol());
   tick_series.SetAvailable(true);
   tick_series.SetRequiredUsedDays();
   tick_series.Create();
   tick_series.Print();
   
   Print("");
//--- Get and display in the journal the data of an object with the highest Ask price in the daily price range
   int index_max=CSelect::FindTickDataMax(tick_series.GetList(),TICK_PROP_ASK);
   CDataTick *tick_max=tick_series.GetList().At(index_max);
   if(tick_max!=NULL)
      tick_max.Print();
//--- Get and display in the journal the data of an object with the lowest Bid price in the daily price range
   int index_min=CSelect::FindTickDataMin(tick_series.GetList(),TICK_PROP_BID);
   CDataTick *tick_min=tick_series.GetList().At(index_min);
   if(tick_min!=NULL)
      tick_min.Print();

//--- Create resource text files
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_coin_01",TextByLanguage("Звук упавшей монетки 1","Falling coin 1"),sound_array_coin_01);
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_coin_02",TextByLanguage("Звук упавших монеток","Falling coins"),sound_array_coin_02);
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_coin_03",TextByLanguage("Звук монеток","Coins"),sound_array_coin_03);
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_coin_04",TextByLanguage("Звук упавшей монетки 2","Falling coin 2"),sound_array_coin_04);
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_click_01",TextByLanguage("Звук щелчка по кнопке 1","Button click 1"),sound_array_click_01);
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_click_02",TextByLanguage("Звук щелчка по кнопке 2","Button click 2"),sound_array_click_02);
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_click_03",TextByLanguage("Звук щелчка по кнопке 3","Button click 3"),sound_array_click_03);
   engine.CreateFile(FILE_TYPE_WAV,"sound_array_cash_machine_01",TextByLanguage("Звук кассового аппарата","Cash machine"),sound_array_cash_machine_01);
   engine.CreateFile(FILE_TYPE_BMP,"img_array_spot_green",TextByLanguage("Изображение \"Зелёный светодиод\"","Image \"Green Spot lamp\""),img_array_spot_green);
   engine.CreateFile(FILE_TYPE_BMP,"img_array_spot_red",TextByLanguage("Изображение \"Красный светодиод\"","Image \"Red Spot lamp\""),img_array_spot_red);

//--- Pass all existing collections to the main library class
   engine.CollectionOnInit();

//--- Set the default magic number for all used symbols
   engine.TradingSetMagic(engine.SetCompositeMagicNumber(magic_number));
//--- Set synchronous passing of orders for all used symbols
   engine.TradingSetAsyncMode(false);
//--- Set the number of trading attempts in case of an error
   engine.TradingSetTotalTry(InpTotalAttempts);
//--- Set correct order expiration and filling types to all trading objects
   engine.TradingSetCorrectTypeExpiration();
   engine.TradingSetCorrectTypeFilling();

//--- Set standard sounds for trading objects of all used symbols
   engine.SetSoundsStandart();
//--- Set the general flag of using sounds
   engine.SetUseSounds(InpUseSounds);
//--- Set the spread multiplier for symbol trading objects in the symbol collection
   engine.SetSpreadMultiplier(InpSpreadMultiplier);
      
//--- Set controlled values for symbols
   //--- Get the list of all collection symbols
   CArrayObj *list=engine.GetListAllUsedSymbols();
   if(list!=NULL && list.Total()!=0)
     {
      //--- In a loop by the list, set the necessary values for tracked symbol properties
      //--- By default, the LONG_MAX value is set to all properties, which means "Do not track this property" 
      //--- It can be enabled or disabled (by setting the value less than LONG_MAX or vice versa - set the LONG_MAX value) at any time and anywhere in the program
      /*
      for(int i=0;i<list.Total();i++)
        {
         CSymbol* symbol=list.At(i);
         if(symbol==NULL)
            continue;
         //--- Set control of the symbol price increase by 100 points
         symbol.SetControlBidInc(100000*symbol.Point());
         //--- Set control of the symbol price decrease by 100 points
         symbol.SetControlBidDec(100000*symbol.Point());
         //--- Set control of the symbol spread increase by 40 points
         symbol.SetControlSpreadInc(400);
         //--- Set control of the symbol spread decrease by 40 points
         symbol.SetControlSpreadDec(400);
         //--- Set control of the current spread by the value of 40 points
         symbol.SetControlSpreadLevel(400);
        }
      */
     }
//--- Set controlled values for the current account
   CAccount* account=engine.GetAccountCurrent();
   if(account!=NULL)
     {
      //--- Set control of the profit increase to 10
      account.SetControlledValueINC(ACCOUNT_PROP_PROFIT,10.0);
      //--- Set control of the funds increase to 15
      account.SetControlledValueINC(ACCOUNT_PROP_EQUITY,15.0);
      //--- Set profit control level to 20
      account.SetControlledValueLEVEL(ACCOUNT_PROP_PROFIT,20.0);
     }
//--- Get the end of the library initialization time counting and display it in the journal
   ulong end=GetTickCount();
   Print(TextByLanguage("Время инициализации библиотеки: ","Library initialization time: "),TimeMSCtoString(end-begin,TIME_MINUTES|TIME_SECONDS));
  }
//+------------------------------------------------------------------+

Der Code-Block für die Erstellung der Tick-Reihe des aktuellen Symbols für den aktuellen Tag und die Suche nach den beiden notwendigen Tick-Objekten darin, um deren Daten im Journal anzuzeigen, ist ausführlich kommentiert worden. Es sollten also keine Fragen beim Studieren auftauchen. Wenn Sie Fragen haben, können Sie diese gerne in den Kommentaren unten stellen.

Diese Funktion wird in OnInit() berechnet. Daher wird die Liste einmalig beim Start des Programms erstellt. In ihr finden sich sofort zwei Tick-Datenobjekte mit dem höchsten Ask und dem niedrigsten Bid des aktuellen Tages. Die Darstellung der Daten benötigt etwas Zeit. Wenn keine Tick-Daten lokal dargestellt werden, wird deren Download aktiviert.

Kompilieren Sie den EA und starten Sie ihn auf einem beliebigen Symbolchart, der in den Einstellungen vordefiniert wurde, um das aktuelle Symbol und den aktuellen Zeitrahmen zu verwenden. Beim Initialisieren des EA sollen Daten zu EA-Parametern, zu erstellten Zeitreihen, sowie (etwas später) zu erstellten Tick-Serien angezeigt werden. Darunter sollen die Daten zu zwei gefundenen Ticks mit dem höchsten Ask und niedrigsten Bid des Tages angezeigt werden:

Account 8550475: Artyom Trishkin (MetaQuotes Software Corp.) 10426.13 USD, 1:100, Hedge, MetaTrader 5 demo
--- Initializing "DoEasy" library ---
Working with the current symbol only: "EURUSD"
Working with the current timeframe only: H4
EURUSD symbol timeseries: 
- Timeseries "EURUSD" H4: Requested: 1000, Actual: 1000, Created: 1000, On the server: 6336

Tick series "EURUSD": Requested number of days: 1, Historical data created: 276143

============= Beginning of parameter list (Tick "EURUSD" 2021.01.06 14:25:32.156) =============
Last price update time in milliseconds: 2021.01.06 14:25:32.156
Last price update time: 2021.01.06 14:25:32
Volume for the current Last price: 0
Flags: 134
Changed data on the tick:
 - Ask price change
 - Bid price change
------
Bid price: 1.23494
Ask price: 1.23494
Last price: 0.00000
Volume for the current Last price with greater accuracy: 0.00
Spread: 0.00000
------
Symbol: "EURUSD"
============= End of parameter list (Tick "EURUSD" 2021.01.06 14:25:32.156) =============

============= Beginning of parameter list (Tick "EURUSD" 2021.01.07 12:51:40.632) =============
Last price update time in milliseconds: 2021.01.07 12:51:40.632
Last price update time: 2021.01.07 12:51:40
Volume for the current Last price: 0
Flags: 134
Changed data on the tick:
 - Ask price change
 - Bid price change
------
Bid price: 1.22452
Ask price: 1.22454
Last price: 0.00000
Volume for the current Last price with greater accuracy: 0.00
Spread: 0.00002
------
Symbol: "EURUSD"
============= End of parameter list (Tick "EURUSD" 2021.01.07 12:51:40.632) =============

Library initialization time: 00:00:12.828

Die Initialisierung dauerte 12,8 Sekunden — es ist die Zeit für das Hochladen von historischen Tick-Daten.

Was kommt als Nächstes?

Im nächsten Artikel werden wir die Kollektionsklasse der Tick-Daten aller im Programm verwendeten Symbole erstellen und die Aktualisierung aller erstellten Listen in Echtzeit implementieren.

Alle Dateien der aktuellen Version der Bibliothek sind unten zusammen mit der Test-EA-Datei für MQL5 zum Testen und Herunterladen angehängt.
Die Tick-Datenklassen befinden sich in der Entwicklung, daher wird ihre Verwendung in eigenen Programmen in diesem Stadium nicht empfohlen.
Schreiben Sie Ihre Fragen und Vorschläge in den Kommentaren.

Zurück zum Inhalt

Frühere Artikel dieser Serie:

Zeitreihen in der Bibliothek DoEasy (Teil 35): das Balkenobjekt und die Liste der Zeitreihen eines Symbols
Zeitreihen in der Bibliothek DoEasy (Teil 36): Objekt der Zeitreihe für alle verwendeten Symbolzeitrahmen
Zeitreihen in der Bibliothek DoEasy (Teil 37): Kollektion von Zeitreihen - Datenbank der Zeitreihen nach Symbolen und Zeitrahmen
Zeitreihen in der Bibliothek DoEasy (Teil 38): Kollektion von Zeitreihen - Aktualisierungen in Echtzeit und Datenzugriff aus dem Programm
Zeitreihen in der Bibliothek DoEasy (Teil 40): Bibliotheksbasierte Indikatoren - Aktualisierung der Daten in Echtzeit
Zeitreihen in der Bibliothek DoEasy (Teil 41): Beispiel eines Multi-Symbol- und Multi-Zeitrahmen-Indikators
Zeitreihen in der Bibliothek DoEasy (Teil 42): Abstrakte Objektklasse der Indikatorpuffer
Zeitreihen in der Bibliothek DoEasy (Teil 43): Klassen der Objekte von Indikatorpuffern
Zeitreihen in der Bibliothek DoEasy (Teil 44): Kollektionsklasse der Objekte von Indikatorpuffern
Zeitreihen in der Bibliothek DoEasy (Teil 45): Puffer für Mehrperiodenindikator
Zeitreihen in der Bibliothek DoEasy (Teil 46): Mehrperioden-Multisymbol-Indikatorpuffer
Zeitreihen in der Bibliothek DoEasy (Teil 47): Standardindikatoren für mehrere Symbole und Perioden
Zeitreihen in der Bibliothek DoEasy (Teil 48): Mehrperioden-Multisymbol-Indikatoren mit einem Puffer in einem Unterfenster
Zeitreihen in der Bibliothek DoEasy (Teil 49): Standardindikatoren mit mehreren Puffern für mehrere Symbole und Perioden
Zeitreihen in der Bibliothek DoEasy (Teil 50): Verschieben der Standardindikatoren für mehrere Symbole und Perioden
Zeitreihen in der Bibliothek DoEasy (Teil 51): Zusammengesetzte Standardindikatoren für mehrere Symbole und Perioden
Zeitreihen in der Bibliothek DoEasy (Teil 52): Plattformübergreifende Eigenschaft für Standardindikatoren mit einem Puffer für mehrere Symbole und Perioden
Zeitreihen in der Bibliothek DoEasy (Teil 53): Abstrakte Basisklasse der Indikatoren
Zeitreihen in der Bibliothek DoEasy (Teil 54): Abgeleitete Klassen des abstrakten Basisindikators
Zeitreihen in der Bibliothek DoEasy (Teil 55): Die Kollektionsklasse der Indikatoren
Zeitreihen in der Bibliothek DoEasy (Teil 56): Nutzerdefiniertes Indikatorobjekt, das die Daten von Indikatorobjekten aus der Kollektion holt
Zeitreihen in der Bibliothek DoEasy (Teil 57): Das Datenobjekt der Indikatorpuffer
Zeitreihen in der Bibliothek DoEasy (Teil 58): Zeitreihen der Datenpuffer von Indikatoren
Zeitreihen in der Bibliothek DoEasy (Teil 59): Objekt zum Speichern der Daten eines Ticks


Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/8912

Beigefügte Dateien |
MQL5.zip (3874.87 KB)
Letzte Kommentare | Zur Diskussion im Händlerforum (3)
MarcDavidTolkmitt
MarcDavidTolkmitt | 21 Mrz 2021 in 19:22

Diese Serie DoEasy fand ich ja interessant. Nur leider kennen wir uns nicht. Sie erwarten Humor. Nur, wofür?

Man kann das Rad nicht neu erfinden! Und dieser Autor der Serie "DoEasy" will sowas. Schwachsinn startet beim "Encapseln" von "Enumerations" der Engine von Meta Trade. Meiner Meinung ist hier sehr viel Zeit auf Listings und Verkapselung vergeudet worden. Normale OOP geht nicht in Listings rein, sondern in Algorithmen! Das fehlt hier komplett. Der Autor redet konstant von bewältigbaren Texten, aber so ist es nicht! Normal wär bei DEM Volumen, daß es auch einen Wert gibt. Aber der fehlt bei mir.

Die Beispiele gibt es nur im Debug-Modus - also nur zum sehen. Dementsprechend ist es bisher verlorene Zeit.

Bei mir ist es jetzt so bei Volumen Nr.60 angekommen! Das ist kein Wert - auch wenn der Autor sowas präsentiert. Wo ist der Inhalt, außer das ein Softwarebüro fleißig Listen generiert hat?

Eine Perspektive ist doch egal - Serverdaten sind im Minutentakt ( CopyRates!!! ). Dort geht doch alles hin. Für den Broker gibt es nur Minuten - und in der Zwischenzeit werden alle Kunden eingeladen/bedient.

Ich bin mir meiner Kritik bewusst. Sehr wenig Algorithmen sind in viel Text verpackt worden! Und dabei kann diskutiert werden, ob "C++ der "beste Weg als Ausdruck" ist, den es gibt!

Und dabei wollte ich Ihnen sagen, daß das Rad nicht neu erfunden werden muß!

mfG

Marc Tolkmitt

Carl Schreiber
Carl Schreiber | 21 Mrz 2021 in 21:00
MarcDavidTolkmitt:

Diese Serie DoEasy fand ich ja interessant. Nur leider kennen wir uns nicht. Sie erwarten Humor. Nur, wofür?

Man kann das Rad nicht neu erfinden! Und dieser Autor der Serie "DoEasy" will sowas. Schwachsinn startet beim "Encapseln" von "Enumerations" der Engine von Meta Trade. Meiner Meinung ist hier sehr viel Zeit auf Listings und Verkapselung vergeudet worden. Normale OOP geht nicht in Listings rein, sondern in Algorithmen! Das fehlt hier komplett. Der Autor redet konstant von bewältigbaren Texten, aber so ist es nicht! Normal wär bei DEM Volumen, daß es auch einen Wert gibt. Aber der fehlt bei mir.

Die Beispiele gibt es nur im Debug-Modus - also nur zum sehen. Dementsprechend ist es bisher verlorene Zeit.

Bei mir ist es jetzt so bei Volumen Nr.60 angekommen! Das ist kein Wert - auch wenn der Autor sowas präsentiert. Wo ist der Inhalt, außer das ein Softwarebüro fleißig Listen generiert hat?

Eine Perspektive ist doch egal - Serverdaten sind im Minutentakt ( CopyRates!!! ). Dort geht doch alles hin. Für den Broker gibt es nur Minuten - und in der Zwischenzeit werden alle Kunden eingeladen/bedient.

Ich bin mir meiner Kritik bewusst. Sehr wenig Algorithmen sind in viel Text verpackt worden! Und dabei kann diskutiert werden, ob "C++ der "beste Weg als Ausdruck" ist, den es gibt!

Und dabei wollte ich Ihnen sagen, daß das Rad nicht neu erfunden werden muß!

mfG

Marc Tolkmitt

Bitte Vorsicht und Respekt im Ton. Der Autor hat sehr viel Wissen über das Verhalten des Terminals. Die Daten kommen vom Server Tick für Tick und nicht minutenweise, auch der Stratgietester kann mit Ticks arbeiten. Es kann daher für jemanden durchaus Sinn machen, Ticks in einem Array aktuell zuhalten.

Außerdem beschäftigen sich Teile mit dem Erstellen grafischer Objekte, um den Eigenhandel zu überwachen. Da können sich Interessierte wichtige Teile heraus kopieren, die sie dann nicht selber mit allen Fehlern erstellen müssten.

Artyom Trishkin
Artyom Trishkin | 22 Mrz 2021 in 05:39
MarcDavidTolkmitt :

Diese Serie DoEasy fand ich ja interessant. Nur leider kennen wir uns nicht. Sie erwarten Humor. Nur, wofür?

Man kann das Rad nicht neu erfinden! Und dieser Autor der Serie "DoEasy" will sowas. Schwachsinn startet beim "Encapseln" von "Enumerations" der Engine von Meta Trade. Meiner Meinung ist hier sehr viel Zeit auf Listings und Verkapselung vergeudet worden. Normale OOP geht nicht in Listings rein, sondern in Algorithmen! Das fehlt hier komplett. Der Autor redet konstant von bewältigbaren Texten, aber so ist es nicht! Normal wär bei DEM Volumen, daß es auch einen Wert gibt. Aber der fehlt bei mir.

Die Beispiele gibt es nur im Debug-Modus - also nur zum sehen. Dementsprechend ist es bisher verlorene Zeit.

Bei mir ist es jetzt so bei Volumen Nr.60 angekommen! Das ist kein Wert - auch wenn der Autor sowas präsentiert. Wo ist der Inhalt, außer das ein Softwarebüro fleißig Listen generiert hat?

Eine Perspektive ist doch egal - Serverdaten sind im Minutentakt ( CopyRates !!! ). Dort geht doch alles hin. Für den Broker gibt es nur Minuten - und in der Zwischenzeit werden alle Kunden eingeladen/bedient.

Ich bin mir meiner Kritik bewusst. Sehr wenig Algorithmen sind in viel Text verpackt worden! Und dabei kann diskutiert werden, ob "C++ der "beste Weg als Ausdruck" ist, den es gibt!

Und dabei wollte ich Ihnen sagen, daß das Rad nicht neu erfunden werden muß!

mfG

Marc Tolkmitt

Danke für Ihre Rückmeldung.

Im Moment sprechen die Artikel über den Entwicklungsprozess der Bibliothek. Die Bibliothek sollte verschiedene Aspekte der Arbeit mit dem Terminal abdecken, damit es nicht klein ist. Die Eigenschaften verschiedener Bibliotheksobjekte wiederholen die Aufzählungen der Parameter der Funktionen der MQL5-Sprache, und dies ist natürlich, aber den Eigenschaften werden neue hinzugefügt. Dies ist für die korrekte Sortierung von Objekten nach diesen Eigenschaften erforderlich. Eine Sortierung ist erforderlich, um ein Objekt schnell nach einer bestimmten Eigenschaft zu finden. Sie können natürlich mathematische Berechnungen der Indizes jeder Eigenschaft aus den Standardindizes verwenden, aber viel klarer, flexibler und weniger fehlerhaft, um Ihre eigenen Aufzählungen als Eigenschaften von Objekten zu verwenden.

Objektlisten werden für den schnellen Zugriff auf ihre Eigenschaften benötigt und sind die Grundlage für die Erstellung von Logik und Algorithmen. In naher Zukunft ist ein großer Abschnitt über Grafikobjekte geplant, der mit allen verfügbaren bereits erstellten Bibliotheksobjekten ausgestattet wird, mit denen Sie Ihre eigenen Grafikschnittstellen in Ihren Programmen erstellen können. Voll interaktiv.

Die Erstellung verschiedener Algorithmen aus einer vollständig fertigen Objektbasis ist für die allerletzte Stufe der Bibliotheksbeschreibung geplant.
Es wäre seltsam, "ein Auto zu fahren", für das nur das Lenkrad und die Pedale hergestellt sind.

---------

Спасибо за отзыв.

На данный момент в статьях рассказывается о процессе разработки библиотеки. Библиотека должна охватывать разные аспекты работы с терминалом, поэтому она не маленькая. Свойства различных объектов библиотеки повторяют перечисления параметров функций языка MQL5, и это естественно, но к свойствам добавляются новые. Это нужно для правильной сортировки объектов по этим свойствам. А сортировка нужна для быстрого поиска объекта по заданному свойству. Можно конечно использовать математические вычисления индексов каждого свойства от стандартных, но куда более наглядно, более гибко и менее ошибочно использовать собственные перечисления в качестве свойств объектов.

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

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

Mehrschicht-Perceptron und Backpropagation-Algorithmus Mehrschicht-Perceptron und Backpropagation-Algorithmus
Die Popularität dieser beiden Methoden wächst, sodass viele Bibliotheken in Matlab, R, Python, C++ und anderen entwickelt wurden, die einen Trainingssatz als Eingabe erhalten und automatisch ein passendes Netzwerk für das Problem erstellen. Versuchen wir zu verstehen, wie der Grundtyp des neuronalen Netzes funktioniert (einschließlich Ein-Neuronen-Perzeptron und Mehrschicht-Perzeptron). Wir werden einen spannenden Algorithmus betrachten, der für das Training des Netzes verantwortlich ist - Gradientenabstieg und Backpropagation. Bestehende komplexe Modelle basieren oft auf solchen einfachen Netzwerkmodellen.
Entwicklung eines selbstanpassenden Algorithmus (Teil III): Verzicht auf Optimierung Entwicklung eines selbstanpassenden Algorithmus (Teil III): Verzicht auf Optimierung
Es ist unmöglich, einen wirklich stabilen Algorithmus zu erhalten, wenn wir die Optimierung auf Basis historischer Daten zur Auswahl der Parameter verwenden. Ein stabiler Algorithmus sollte wissen, welche Parameter bei der Arbeit an einem beliebigen Handelsinstrument zu jeder Zeit benötigt werden. Er sollte nicht prognostizieren oder raten, er sollte es mit Sicherheit wissen.
Preise in der DoEasy-Bibliothek (Teil 61): Kollektion der Tickserien eines Symbols Preise in der DoEasy-Bibliothek (Teil 61): Kollektion der Tickserien eines Symbols
Da ein Programm bei seiner Arbeit verschiedene Symbole verwenden kann, sollte für jedes dieser Symbole eine eigene Liste erstellt werden. In diesem Artikel werde ich solche Listen zu einer Tickdatenkollektion zusammenfassen. In der Tat wird dies eine reguläre Liste sein, die auf der Klasse des dynamischen Arrays von Zeigern auf Instanzen der Klasse CObject und ihrer Nachkommen der Standardbibliothek basiert.
Praktische Anwendung von Neuronalen Netzen im Handel (Teil 2). Computerbilder Praktische Anwendung von Neuronalen Netzen im Handel (Teil 2). Computerbilder
Die Verwendung von Computerbilder ermöglicht das Training von Neuronalen Netzen auf der visuellen Darstellung des Kurscharts und der Indikatoren. Diese Methode ermöglicht breitere Operationen mit dem ganzen Komplex der technischen Indikatoren, da es nicht nötig ist, sie digital in das Neuronale Netz einzuspeisen.