Trabajando con los precios en la biblioteca DoEasy (Parte 61): Colección de series de tick de los símbolos
281
0
Contenido
Concepto
En el artículo anterior, creamos una clase del objeto de lista de datos de tick en la que se reúnen y se almacenan los ticks del símbolo para una cantidad de días establecida. Dado que el programa puede utilizar varios símbolos, entonces, es necesario crear su propia lista para cada uno de estos símbolos. En este artículo, vamos a combinar estas listas en una colección de datos de tick. En realidad, se trata de una lista común a base de la clase de la matriz dinámica de punteros a las instancias de la clase CObject y sus herederos de la Biblioteca estándar. Esta lista va a almacenar punteros a las listas de datos de tick creadas para cada símbolo, cuya clase de objetos fue preparada en el artículo anterior.
Este concepto es idéntico al concepto de la construcción de las clases de colección anteriores en la biblioteca. Nos permitirá guardar, almacenar, actualizar, obtener y usar en estudios estadísticos los datos de tick de cualquier símbolo que se encuentra en la base de la biblioteca.
Clase de colección de datos de tick
En el catálogo de la biblioteca \MQL5\Include\DoEasy\Collections\ creamos un nuevo archivo de la clase de colección de datos de tick con el nombre TickSeriesCollection.mqh.
La clase va a derivarse de la clase del objeto básico de todos los objetos de la biblioteca.
Vamos a examinar el cuerpo de la clase, luego analizaremos todas sus variables y métodos:
//+------------------------------------------------------------------+ //| TickSeriesCollection.mqh | //| Copyright 2021, MetaQuotes Software Corp. | //| https://mql5.com/es/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2021, MetaQuotes Software Corp." #property link "https://mql5.com/es/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "ListObj.mqh" #include "..\Objects\Ticks\TickSeries.mqh" #include "..\Objects\Symbols\Symbol.mqh" //+------------------------------------------------------------------+ //| Collection of symbol tick series | //+------------------------------------------------------------------+ class CTickSeriesCollection : public CBaseObj { private: CListObj m_list; // List of used symbol tick series //--- Return the tick series index by symbol name int IndexTickSeries(const string symbol); public: //--- Return (1) itself and (2) tick series collection list and (3) the number of tick series in the list CTickSeriesCollection *GetObject(void) { return &this; } CArrayObj *GetList(void) { return &this.m_list; } int DataTotal(void) const { return this.m_list.Total(); } //--- Return the pointer to the tick series object (1) by symbol and (2) by index in the list CTickSeries *GetTickseries(const string symbol); CTickSeries *GetTickseries(const int index); //--- Create a collection list of symbol tick series bool CreateCollection(const CArrayObj *list_symbols,const uint required=0); //--- Set the flag of using the tick series of (1) a specified symbol and (2) all symbols void SetAvailableTickSeries(const string symbol,const bool flag=true); void SetAvailableTickSeries(const bool flag=true); //--- Return the flag of using the tick series of (1) a specified symbol and (2) all symbols bool IsAvailableTickSeries(const string symbol); bool IsAvailableTickSeries(void); //--- Set the number of days of the tick history of (1) a specified symbol and (2) all symbols bool SetRequiredUsedDays(const string symbol,const uint required=0); bool SetRequiredUsedDays(const uint required=0); //--- Return the last tick object of a specified symbol (1) by index, (2) by time and (4) by time in milliseconds CDataTick *GetTick(const string symbol,const int index); CDataTick *GetTick(const string symbol,const datetime tick_time); CDataTick *GetTick(const string symbol,const long tick_time_msc); //--- Return the new tick flag of a specified symbol bool IsNewTick(const string symbol); //--- Create a tick series of (1) a specified symbol and (2) all symbols bool CreateTickSeries(const string symbol,const uint required=0); bool CreateTickSeriesAll(const uint required=0); //--- Update (1) a tick series of a specified symbol and (2) all symbols void Refresh(const string symbol); void Refresh(void); //--- Display (1) the complete and (2) short collection description in the journal void Print(void); void PrintShort(void); //--- Constructor CTickSeriesCollection(); }; //+------------------------------------------------------------------+
La variable de miembro de clase m_list es del tipo CListObj —la clase que se deriva de la clase CArrayObj de la biblioteca estándar, igual como muchas listas creadas en esta biblioteca. El único objetivo de la clase CListObj consiste en implementar el funcionamiento del método virtual Type() de la clase CObject —la clase básica de los objetos de la biblioteca estándar. El método tiene que devolver el identificador del tipo de la clase. En este caso, es el identificador del tipo de la matriz.
El método virtual Type() está implementado en la clase CListObj, la cual fue añadida a la biblioteca desde hace tiempo:
//+------------------------------------------------------------------+ //| ListObj.mqh | //| Copyright 2019, MetaQuotes Software Corp. | //| https://mql5.com/es/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2019, MetaQuotes Software Corp." #property link "https://mql5.com/es/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include <Arrays\ArrayObj.mqh> //+------------------------------------------------------------------+ //| Class of collection lists | //+------------------------------------------------------------------+ class CListObj : public CArrayObj { private: int m_type; // List type public: void Type(const int type) { this.m_type=type; } virtual int Type(void) const { return(this.m_type); } CListObj() { this.m_type=0x7778; } }; //+------------------------------------------------------------------+
Aquí, el método Type() establece el valor transmitido para la variable m_type, mientras que el método virtual Type() devuelve el valor establecido por esta variable.
Por defecto, (en el constructor de la clase) para la variable se le establece el mismo valor del identificador del tipo de la matriz como para CArrayObj — 0x7778.
La finalidad de todos los métodos de la clase se describe en los comentarios del código. A continuación, analizaremos la implementación de estos métodos.
En el constructor de la clase, limpiamos la lista, asignamos a la lista la bandera de lista clasificada y
definimos el indentificador de la lista de colección de datos de tick:
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CTickSeriesCollection::CTickSeriesCollection() { this.m_list.Clear(); this.m_list.Sort(); this.m_list.Type(COLLECTION_TICKSERIES_ID); } //+------------------------------------------------------------------+
El método privado IndexTickSeries() devuelve el índice de la serie de tick según el nombre del símbolo:
//+------------------------------------------------------------------+ //| Return the tick series index by symbol name | //+------------------------------------------------------------------+ int CTickSeriesCollection::IndexTickSeries(const string symbol) { const CTickSeries *obj=new CTickSeries(symbol==NULL || symbol=="" ? ::Symbol() : symbol); if(obj==NULL) return WRONG_VALUE; this.m_list.Sort(); int index=this.m_list.Search(obj); delete obj; return index; } //+------------------------------------------------------------------+
El método recibe el nombre del símbolo, cuyo índice de la serie de tick debe ser devuelto desde la lista.
Luego, creamos un objeto temporal vacío de la serie de tick, asignándole el nombre del símbolo transmitido al método.
Establecemos la bandera de una lista ordenada y buscamos el índice del objeto en la lista.
Luego, eliminamos el objeto temporal y devolvemos el índice obtenido. Si el objeto no ha sido encontrado o la creación del objeto temporal ha fallado, el método devuelve NULL.
El método que devuelve el puntero al objeto de las series de tick según el símbolo:
//+------------------------------------------------------------------+ //| Return the object of tick series of a specified symbol | //+------------------------------------------------------------------+ CTickSeries *CTickSeriesCollection::GetTickseries(const string symbol) { int index=this.IndexTickSeries(symbol); return this.m_list.At(index); } //+------------------------------------------------------------------+
El método recibe el nombre del símbolo, cuyo objeto de la serie de tick debe ser devuelto desde la lista.
Usamos el método que acabamos de analizar para buscar el índice del objeto de la serie de tick en la lista, obtenemos el puntero a este objeto según el índice encontrado y lo devolvemos. Si el índice no ha sido encontrado, su valor será igual a -1, y el método At() de la clase CArrayObj devolverá NULL.
El método que establece la bandera del uso de la serie de tick del símbolo especificado
//+------------------------------------------------------------------+ //| Set the flag of using the tick series of a specified symbol | //+------------------------------------------------------------------+ void CTickSeriesCollection::SetAvailableTickSeries(const string symbol,const bool flag=true) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return; tickseries.SetAvailable(flag); } //+------------------------------------------------------------------+
Al método se le transmite el nombre del símbolo, cuyo objeto de la serie de tick debe recibir la bandera del uso.
Usamos el método GetTickseries() considerado antespara obtener el puntero al objeto de la serie de tick desde la lista y
le asignamos la bandera transmitida al método.
El método que establece la bandera del uso de las series de tick de todos los símbolos de la colección:
//+------------------------------------------------------------------+ //| Set the flag of using the tick series of all symbols | //+------------------------------------------------------------------+ void CTickSeriesCollection::SetAvailableTickSeries(const bool flag=true) { for(int i=0;i<this.m_list.Total();i++) { CTickSeries *tickseries=this.m_list.At(i); if(tickseries==NULL) continue; tickseries.SetAvailable(flag); } } //+------------------------------------------------------------------+
En el ciclo, por el número total de las series de tick en la lista,
obtenemos el siguiente objeto de la serie de tick según el índice del ciclo y
le establecemos la bandera transmitida al método.
El método que devuelve la bandera del uso de la serie de tick del símbolo especificado
//+------------------------------------------------------------------+ //| Return the flag of using the tick series of a specified symbol | //+------------------------------------------------------------------+ bool CTickSeriesCollection::IsAvailableTickSeries(const string symbol) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return false; return tickseries.IsAvailable(); } //+------------------------------------------------------------------+
El método recibe el nombre del símbolo, cuya bandera del uso del objeto de la serie de tick debe ser devuelta.
Usamos el método GetTickseries() para obtener el puntero al objeto de la serie de tick del símbolo necesario y
devolvemos la bandera del uso establecida para este objeto. Si no se ha podido obtener el objeto de la lista, el método devuelve false
.
El método que devuelve la bandera del uso de las series de tick de todos los símbolos:
//+------------------------------------------------------------------+ //| Return the flag of using tick series of all symbols | //+------------------------------------------------------------------+ bool CTickSeriesCollection::IsAvailableTickSeries(void) { bool res=true; int total=this.m_list.Total(); for(int i=0;i<total;i++) { CTickSeries *tickseries=this.m_list.At(i); if(tickseries==NULL) continue; res &=tickseries.IsAvailable(); } return res; } //+------------------------------------------------------------------+
Declaramos la variable res y la inicializamos usando el valor true.
Luego, en el ciclo por el número total de los objetos en la lista,
obtenemos el puntero al siguiente objeto de la serie de tick y
añadimos la bandera del uso establecida para el objeto actual al valor de la variable res.
Una vez finalizado el ciclo, retornamos el valor obtenido de la variable res.
Si por lo menos un objeto de la lista va carecer de la bandera del uso (false), la variable res va a almacenar el valor false cuando se finalice el ciclo. De esta manera, el método permite averiguar si las banderas del uso están establecidas para todas las series de tick de la colección. True se devuelve solamente si las banderas del uso han sido establecidas como true para cada objeto de la serie de tick en la colección.
El método que establece el número de días del historial de ticks para el símbolo especificado:
//+------------------------------------------------------------------+ //| Set the number of days of the tick history of a specified symbol | //+------------------------------------------------------------------+ bool CTickSeriesCollection::SetRequiredUsedDays(const string symbol,const uint required=0) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return false; tickseries.SetRequiredUsedDays(required); return true; } //+------------------------------------------------------------------+
Al método se le transfiere el nombre del símbolo, para el cual hay que establecer la cantidad de días de datos de tick.
Obtenemos el puntero al objeto de las series de tick usando el método considerado antes,
establecemos el número de días para él y devolvemos true.
Si no se ha podido obtener el puntero al objeto de las series de tick, el método devuelve false
El método que establece el número de días del historial de ticks de todos los símbolos:
//+------------------------------------------------------------------+ //| Set the number of days of the tick history of all symbols | //+------------------------------------------------------------------+ bool CTickSeriesCollection::SetRequiredUsedDays(const uint required=0) { bool res=true; for(int i=0;i<this.m_list.Total();i++) { CTickSeries *tickseries=this.m_list.At(i); if(tickseries==NULL) { res &=false; continue; } tickseries.SetRequiredUsedDays(required); } return res; } //+------------------------------------------------------------------+
Declaramos la variable res y la inicializamos usando el valor true.
Luego, en el ciclo por el número total de los objetos en la lista,
obtenemos el puntero al siguiente objeto de la serie de tick y
si no se ha podido obtener el puntero al objeto,
añadimos el valor false al valor de la variable res. Luego, vamos al siguiente objeto en la lista de colección.
De lo contrario, establecemos el número de días de datos de tick para el objeto actual.
Una vez finalizado el ciclo, retornamos el valor obtenido de la variable res.
Si por lo menos un objeto de la lista no va a tener establecido el número de días de datos de tick, la variable res va a almacenar el valor false cuando se finalice el ciclo. De esta manera, el método permite establecer el número de días para todas las series de tick, y devuelve el éxito de la ejecución sólo si el número de días se establece para cada uno de los objetos de datos de tick almacenados en la lista.
El método que devuelve el objeto de tick del símbolo especificado según el índice en la lista de la serie de tick:
//+------------------------------------------------------------------+ //| Return the tick object of the specified symbol by index | //+------------------------------------------------------------------+ CDataTick *CTickSeriesCollection::GetTick(const string symbol,const int index) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return NULL; return tickseries.GetTickByListIndex(index); } //+------------------------------------------------------------------+
El método recibe el símbolo de la serie de tick de la clase CTickSeries y el índice del objeto de tick necesario que se almacena en la lista de la serie de tick.
Obtenemos el puntero al objeto de la serie de tick desde la lista de colección según el símbolo usando el método GetTickseries() descrito antes, y
devolvemos el puntero al objeto de tick desde la lista de la serie de tick usando el método GetTickByListIndex() considerado en el artículo anterior.
Si no se ha podido obtener el objeto de la serie de tick desde la lista de colección, el método devuelve NULL. Además, NULL puede ser devuelto también por el método GetTickByListIndex() de la clase CTickSeries.
El método que devuelve el último objeto de tick del símbolo especificado según la hora desde la lista de la serie de tick:
//+------------------------------------------------------------------+ //| Return the last tick object of the specified symbol by time | //+------------------------------------------------------------------+ CDataTick *CTickSeriesCollection::GetTick(const string symbol,const datetime tick_time) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return NULL; return tickseries.GetTick(tick_time); } //+------------------------------------------------------------------+
El método recibe el símbolo de la serie de tick de la clase CTickSeries y la hora del objeto de tick necesario que se almacena en la lista de la serie de tick.
Obtenemos el puntero al objeto de la serie de tick desde la lista de colección según el símbolo usando el método GetTickseries() descrito antes, y
devolvemos el puntero al objeto de tick desde la lista de la serie de tick usando el método GetTick() considerado en el artículo anterior.
Si no se ha podido obtener el objeto de la serie de tick desde la lista de colección, el método devuelve NULL. Además, NULL puede ser devuelto también por el método GetTick() de la clase CTickSeries.
El método que devuelve el último objeto de tick del símbolo especificado según la hora en milisegundos desde la lista de la serie de tick:
//+------------------------------------------------------------------+ //| Return the last tick object of the specified symbol | //| by time in milliseconds | //+------------------------------------------------------------------+ CDataTick *CTickSeriesCollection::GetTick(const string symbol,const long tick_time_msc) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return NULL; return tickseries.GetTick(tick_time_msc); } //+------------------------------------------------------------------+
El método recibe el símbolo de la serie de tick de la clase CTickSeries y la hora en milisegundos del objeto de tick necesario que se almacena en la lista de la serie de tick.
Obtenemos el puntero al objeto de la serie de tick desde la lista de colección según el símbolo usando el método GetTickseries() descrito antes, y
devolvemos el puntero al objeto de tick desde la lista de la serie de tick usando el método GetTick() considerado en el artículo anterior.
Si no se ha podido obtener el objeto de la serie de tick desde la lista de colección, el método devuelve NULL. Además, NULL puede ser devuelto también por el método GetTick() de la clase CTickSeries.
Es necesario precisar una cosa. Puede haber varios ticks con la hora igual para dos últimos métodos que devuelven los objetos de tick según la hora. Por eso, el método GetTick() de la clase CTickSeries devuelve el último de ellos, es decir, con la hora más reciente como el más relevante.
El método que devuelve la bandera del nuevo tick del símbolo especificado
//+------------------------------------------------------------------+ //| Return the new tick flag of a specified symbol | //+------------------------------------------------------------------+ bool CTickSeriesCollection::IsNewTick(const string symbol) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return false; return tickseries.IsNewTick(); } //+------------------------------------------------------------------+
El método recibe el nombre del símbolo, cuya bandera de la llegada del nuevo tick debe ser devuelta.
Obtenemos el puntero al objeto de la serie de tick desde la lista de colección según el símbolo usando el método GetTickseries() descrito antes, y
devolvemos la bandera del nuevo tick de la serie de tick usando el método IsNewTick() de la clase CTickSeries, que consideramos en el artículo anterior.
Si no se ha podido obtener el objeto de la serie de tick desde la lista de colección, el método devuelve false.
Cabe señalar que, de momento, esta posibilidad todavía no está implementada en la clase CTickSeries. Nos ocuparemos de ello en los artículos posteriores.
Método para crear una serie de tick del símbolo especificado:
//+------------------------------------------------------------------+ //| Create a tick series of a specified symbol | //+------------------------------------------------------------------+ bool CTickSeriesCollection::CreateTickSeries(const string symbol,const uint required=0) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return false; return(tickseries.Create(required)>0); } //+------------------------------------------------------------------+
Al método se le transmite el nombre del símbolo, cuya serie de tick debe ser creada, así como el número de días de datos de tick.
Obtenemos el puntero al objeto de la serie de tick desde la lista de colección según el símbolo usando el método GetTickseries() descrito antes, y
devolvemos la bandera de que el método Create() de la clase CTickSeries ha devuelto un valor mayor a cero (el número de los objetos de tick no es igual a cero).
Método para crear series de tick de todos los símbolos utilizados:
//+------------------------------------------------------------------+ //| Create tick series of all symbols | //+------------------------------------------------------------------+ bool CTickSeriesCollection::CreateTickSeriesAll(const uint required=0) { bool res=true; int total=this.m_list.Total(); for(int i=0;i<total;i++) { CTickSeries *tickseries=this.m_list.At(i); if(tickseries==NULL) continue; res &=(tickseries.Create(required)>0); } return res; } //+------------------------------------------------------------------+
Al método se le transmite la cantidad de días de datos de tick.
Declaramos la variable res y la inicializamos usando el valor true.
Luego, en el ciclo por el número total de los objetos en la lista,
obtenemos el puntero al siguiente objeto de la serie de tick y
añadimos al valor de la variable res la bandera de que el valor devuelto por elmétodo Create() de la clase CTickSeries es mayor a cero (la serie de tick está creada)
Una vez finalizado el ciclo, retornamos el valor obtenido de la variable res.
Si por lo menos un objeto de la lista no va a tener creada la serie de tick, la variable res va a almacenar el valor false cuando se finalice el ciclo. De esta manera, el método permite crear las colecciones de las series de tick para todos los símbolos, y devuelve el éxito de la ejecución sólo si las series de tick se crean para cada uno de los objetos de datos de tick almacenados en la lista.
Método para actualizar a serie de tick del símbolo especificado:
//+------------------------------------------------------------------+ //| Update a tick series of a specified symbol | //+------------------------------------------------------------------+ void CTickSeriesCollection::Refresh(const string symbol) { CTickSeries *tickseries=this.GetTickseries(symbol); if(tickseries==NULL) return; tickseries.Refresh(); } //+------------------------------------------------------------------+
Al método se le transmite el nombre del símbolo para el cual es necesario actualizar la serie de tick.
Obtenemos el puntero al objeto de la serie de tick desde la lista de colección según el símbolo usando el método GetTickseries() descrito antes, y
la actualizamos usando el método Refresh() de la clase CTickSeries.
Método para actualizar las series de tick para todos los símbolos:
//+------------------------------------------------------------------+ //| Update tick series of all symbols | //+------------------------------------------------------------------+ void CTickSeriesCollection::Refresh(void) { for(int i=0;i<this.m_list.Total();i++) { CTickSeries *tickseries=this.m_list.At(i); if(tickseries==NULL) continue; tickseries.Refresh(); } } //+------------------------------------------------------------------+
En el ciclo por el número total de los objetos en la lista
obtenemos el puntero al siguiente objeto de la serie de tick según el índice del ciclo, y
actualizamos la serie usando el método Refresh() de la clase CTickSeries.
Cabe señalar que, de momento, la posibilidad de actualizar de las series de tick todavía no está implementada en la clase CTickSeries. Nos ocuparemos de ello en los artículos posteriores.
Método que retorna al diario la descripción completa de la colección:
//+------------------------------------------------------------------+ //| Display complete collection description to the journal | //+------------------------------------------------------------------+ void CTickSeriesCollection::Print(void) { for(int i=0;i<this.m_list.Total();i++) { CTickSeries *tickseries=this.m_list.At(i); if(tickseries==NULL) continue; tickseries.Print(); } } //+------------------------------------------------------------------+
En el ciclo por el número total de los objetos en la lista
obtenemos el puntero al siguiente objeto de la serie de tick según el índice del ciclo, y
mostramos la descripción completa de la serie de tick en el diario.
Método que muestra en el diario la descripción breve de la colección:
//+------------------------------------------------------------------+ //| Display the short collection description in the journal | //+------------------------------------------------------------------+ void CTickSeriesCollection::PrintShort(void) { for(int i=0;i<this.m_list.Total();i++) { CTickSeries *tickseries=this.m_list.At(i); if(tickseries==NULL) continue; tickseries.PrintShort(); } } //+------------------------------------------------------------------+
En el ciclo por el número total de los objetos en la lista
obtenemos el puntero al siguiente objeto de la serie de tick según el índice del ciclo, y
mostramos la descripción breve de la serie de tick en el diario.
Los métodos considerados más arriba sirven para trabajar con una lista de colección ya creada para los punteros a los objetos de datos de tick de diferentes símbolos. En nuestros programas, se puede usar diferentes símbolos para su funcionamiento. Se usa el siguiente método para crear el propio objeto de colección con el fin de colocar dentro todas las series de tick necesarios, y luego obtener los punteros desde la lista de colección para trabajar con ellas.
Método para crear la lista de colección de las series de tick de los símbolos:
//+------------------------------------------------------------------+ //| Create a collection list of symbol tick series | //+------------------------------------------------------------------+ bool CTickSeriesCollection::CreateCollection(const CArrayObj *list_symbols,const uint required=0) { //--- If an empty list of symbol objects is passed, exit if(list_symbols==NULL) return false; //--- Get the number of symbol objects in the passed list int total=list_symbols.Total(); //--- Clear the tick series collection list this.m_list.Clear(); //--- In a loop by all symbol objects for(int i=0;i<total;i++) { //--- get the next symbol object CSymbol *symbol_obj=list_symbols.At(i); //--- if failed to get a symbol object, move on to the next one in the list if(symbol_obj==NULL) continue; //--- Create a new empty tick series object CTickSeries *tickseries=new CTickSeries(); //--- If failed to create the tick series object, move on to the next symbol in the list if(tickseries==NULL) continue; //--- Set a symbol name for a tick series object tickseries.SetSymbol(symbol_obj.Name()); //--- Set the sorted list flag for the tick series collection list this.m_list.Sort(); //--- If the object with the same symbol name is already present in the tick series collection list, remove the tick series object if(this.m_list.Search(tickseries)>WRONG_VALUE) delete tickseries; //--- otherwise, there is no object with such a symbol name in the collection yet else { //--- Set the number of tick data days for a tick series object tickseries.SetRequiredUsedDays(required); //--- if failed to add the tick series object to the collection list, remove the tick series object if(!this.m_list.Add(tickseries)) delete tickseries; } } //--- Return the flag indicating that the created collection list has a size greater than zero return this.m_list.Total()>0; } //+------------------------------------------------------------------+
El método es bastante simple. Recibe la lista de los símbolos utilizados en el programa (disponemos de esta lista ya desde hace tiempo, y la usamos para crear la colección de las series temporales de los símbolos). Luego, en el ciclo por el número total de los símbolos, creamos el nuevo objeto de la serie de tick y le establecemos el nombre del símbolo desde la lista de símbolos en la posición actual del ciclo. Si en la lista todavía no hay objeto de la serie de tick con este símbolo, establecemos el valor del número de días de datos de tick transmitido al método y añadimos el objeto a la lista de colección. Hacemos lo mismo para cada símbolo en la lista. Es una descripción breve. Si profundizamos, hay que tomar en cuenta las verificaciones del éxito de la creación y adición de objetos de las series de tick, y la eliminación de los objetos innecesarios si hace falta. Toda la lógica del método se describe detalladamente en su listado. El lector podrá analizarlo por su propia cuenta.
Para vincular la colección creada con el «mundo externo», usamos la clase principal de la biblioteca CEngine.
La clase se almacena en \MQL5\Include\DoEasy\Engine.mqh.
Incluimos el archivo de la clase nuevamente creada:
//+------------------------------------------------------------------+ //| Engine.mqh | //| Copyright 2020, MetaQuotes Software Corp. | //| https://mql5.com/es/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2020, MetaQuotes Software Corp." #property link "https://mql5.com/es/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "Services\TimerCounter.mqh" #include "Collections\HistoryCollection.mqh" #include "Collections\MarketCollection.mqh" #include "Collections\EventsCollection.mqh" #include "Collections\AccountsCollection.mqh" #include "Collections\SymbolsCollection.mqh" #include "Collections\ResourceCollection.mqh" #include "Collections\TimeSeriesCollection.mqh" #include "Collections\BuffersCollection.mqh" #include "Collections\IndicatorsCollection.mqh" #include "Collections\TickSeriesCollection.mqh" #include "TradingControl.mqh" //+------------------------------------------------------------------+
Declaramos el objeto de la clase de colección de las series de tick
en la sección privada de la clase:
//+------------------------------------------------------------------+ //| Library basis class | //+------------------------------------------------------------------+ class CEngine { private: CHistoryCollection m_history; // Collection of historical orders and deals CMarketCollection m_market; // Collection of market orders and deals CEventsCollection m_events; // Event collection CAccountsCollection m_accounts; // Account collection CSymbolsCollection m_symbols; // Symbol collection CTimeSeriesCollection m_time_series; // Timeseries collection CBuffersCollection m_buffers; // Collection of indicator buffers CIndicatorsCollection m_indicators; // Indicator collection CTickSeriesCollection m_tick_series; // Collection of tick series CResourceCollection m_resource; // Resource list CTradingControl m_trading; // Trading management object CPause m_pause; // Pause object CArrayObj m_list_counters; // List of timer counters
En la clase hay método SetUsedSymbols() que permite establecer una lista de símbolos establecidos para el uso en el programa.
Vamos a añadir la transmisión del número de días para los cuales es necesario tener los datos de tick en la biblioteca:
//--- Set the list of used symbols in the symbol collection and create the collection of symbol timeseries bool SetUsedSymbols(const string &array_symbols[],const uint required=0);
Por defecto, se transmite un cero (eso significa un día) y se establece en el archivo \MQL5\Include\DoEasy\Defines.mqh a través de la constante TICKSERIES_DEFAULT_DAYS_COUNT.
En la implementación del método, añadimos la creación de la colección de las series de tick.
//+------------------------------------------------------------------+ //| Set the list of used symbols in the symbol collection | //| and create the symbol timeseries collection | //+------------------------------------------------------------------+ bool CEngine::SetUsedSymbols(const string &array_symbols[],const uint required=0) { bool res=this.m_symbols.SetUsedSymbols(array_symbols); CArrayObj *list=this.GetListAllUsedSymbols(); if(list==NULL) return false; res&=this.m_time_series.CreateCollection(list); res&=this.m_tick_series.CreateCollection(list,required); return res; } //+------------------------------------------------------------------+
Ahora se crean dos colecciones (colección de la serie temporal y colección de las series de tick) cuando este método se invoca desde el programa.
Añadimos a la sección pública de la clase los métodos para acceder a la clase de la colección de las series de tick desde nuestros programas:
//--- Copy the specified double property of the specified timeseries of the specified symbol to the array //--- Regardless of the array indexing direction, copying is performed the same way as copying to a timeseries array bool SeriesCopyToBufferAsSeries(const string symbol,const ENUM_TIMEFRAMES timeframe,const ENUM_BAR_PROP_DOUBLE property, double &array[],const double empty=EMPTY_VALUE) { return this.m_time_series.CopyToBufferAsSeries(symbol,timeframe,property,array,empty);} //--- Return (1) the tick series collection, (2) the list of tick series from the tick series collection CTickSeriesCollection *GetTickSeriesCollection(void) { return &this.m_tick_series; } CArrayObj *GetListTickSeries(void) { return this.m_tick_series.GetList(); } //--- Return (1) the buffer collection and (2) the buffer list from the collection
De momento, será suficiente devolver el propio objeto de la colección de las series de tick y la lista de colección desde él al programa.
Por ahora, es todo lo que necesitamos para crear una colección de las series de tick
Prueba
Para la simulación de la creación de una colección de las series de tick de símbolos establecidos para el funcionamiento del programa, vamos a tomar el asesor del artículo anterior y guardarlo en la nueva carpeta \MQL5\Experts\TestDoEasy\Part61\ con el nombre nuevo TestDoEasyPart61.mq5.
Como ahora todas las series de tick están disponibles directamente desde la biblioteca, eliminamos la inclusión de su archivo de la clase en el programa:
//+------------------------------------------------------------------+ //| TestDoEasyPart60.mq5 | //| Copyright 2020, MetaQuotes Software Corp. | //| https://mql5.com/es/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2020, MetaQuotes Software Corp." #property link "https://mql5.com/es/users/artmedia70" #property version "1.00" //--- includes #include <DoEasy\Engine.mqh> #include <DoEasy\Objects\Ticks\TickSeries.mqh> //--- enums
En el área de las variables globales del programa, eliminamos las variables del objeto «Nuevo tick» y del objeto de datos de la serie de tick del símbolo actual:
//--- 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; //+------------------------------------------------------------------+
Al final del manejador OnInit(), eliminamos el establecimiento del símbolo actual para el objeto «Nuevo tick»:
//--- Wait for 600 milliseconds engine.Pause(600); engine.PlaySoundByDescription(TextByLanguage("Звук упавшей монетки 2","Falling coin 2")); //--- Set the current symbol for "New tick" object check_tick.SetSymbol(Symbol()); //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+
Eliminamos de la función OnInitDoEasy() el bloque del código que sirve para verificar la creación de la serie de tick del símbolo actual:
//--- 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
Ahora en vez de eso, tenemos que colocar la creación de las series de tick para todos los símbolo de la colección de datos de tick que ha sido creada:
//--- 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 //--- Create tick series of all used symbols engine.GetTickSeriesCollection().CreateTickSeriesAll(); //--- Check created tick series - display descriptions of all created tick series in the journal engine.GetTickSeriesCollection().Print(); //--- Create resource text files
En el manejador OnTick(), cuando llegue un tick nuevo, intentaremos encontrar un objeto de tick con precio máximo Ask y precio mínimo Bid en las listas de datos de tick usando la colección de les series de tick para cada símbolo, así como, mostrar en el diario los parámetros de cada objeto de tick encontrado:
//+------------------------------------------------------------------+ //| 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 } //--- Check created tick data on the first tick //--- Get and display in the journal the data of an object with the highest Ask price and the lowest Bid price in the daily price range static bool check=false; if(!check) { Print(""); //--- Get the pointer to the list of tick data of all symbols from the tick collection CArrayObj* list=engine.GetTickSeriesCollection().GetList(); int total=engine.GetTickSeriesCollection().DataTotal(); //--- In the loop by the number of tick series in the collection for(int i=0;i<list.Type();i++) { //--- Get the next tick series from the collection by index CTickSeries *tick_series=engine.GetTickSeriesCollection().GetTickseries(i); if(tick_series!=NULL) { //--- In the obtained tick series, find the indices of tick objects with the highest Ask and the lowest Bid int index_max=CSelect::FindTickDataMax(tick_series.GetList(),TICK_PROP_ASK); int index_min=CSelect::FindTickDataMin(tick_series.GetList(),TICK_PROP_BID); //--- Display the data of the tick objects obtained from the tick series in the journal engine.GetTickSeriesCollection().GetTick(tick_series.Symbol(),index_max).Print(); engine.GetTickSeriesCollection().GetTick(tick_series.Symbol(),index_min).Print(); } } check=true; } } //+------------------------------------------------------------------+
Compilamos el EA y lo iniciamos en el gráfico de cualquier símbolo. Previamente, establecemos en los ajustes el uso del marco temporal actual y los símbolos de la lista predefinida, en la cual dejaremos sólo los dos primeros de la lista:
Pasado un rato requerido para crear los datos de tick para estos dos símbolos utilizados en el manejador OnInit(), el diario mostrará datos sobre los parámetros del programa, series temporales creadas y los datos de tick creados. Cuando llegue el primer tick, en el diario se mostrarán los datos de cuatros ticks detectados con Ask máximo y Bid mínimo para cada uno de los dos símbolos:
Account 8550475: Artyom Trishkin (MetaQuotes Software Corp.) 10426.13 USD, 1:100, Hedge, MetaTrader 5 demo --- Initializing "DoEasy" library --- Working with predefined symbol list. The number of used symbols: 2 "AUDUSD" "EURUSD" Working with the current timeframe only: H1 AUDUSD symbol timeseries: - Timeseries "AUDUSD" H1: Requested: 1000, Actual: 1000, Created: 1000, On the server: 6194 EURUSD symbol timeseries: - Timeseries "EURUSD" H1: Requested: 1000, Actual: 1000, Created: 1000, On the server: 5675 Tick series "AUDUSD": Requested number of days: 1, Historical data created: 142712 Tick series "EURUSD": Requested number of days: 1, Historical data created: 113985 Library initialization time: 00:00:06.156 ============= Beginning of parameter list (Tick "AUDUSD" 2021.01.19 10:06:53.387) ============= Last price update time in milliseconds: 2021.01.19 10:06:53.387 Last price update time: 2021.01.19 10:06:53 Volume for the current Last price: 0 Flags: 6 Changed data on the tick: - Ask price change - Bid price change ------ Bid price: 0.77252 Ask price: 0.77256 Last price: 0.00000 Volume for the current Last price with greater accuracy: 0.00 Spread: 0.00004 ------ Symbol: "AUDUSD" ============= End of parameter list (Tick "AUDUSD" 2021.01.19 10:06:53.387) ============= ============= Beginning of parameter list (Tick "AUDUSD" 2021.01.18 11:51:48.662) ============= Last price update time in milliseconds: 2021.01.18 11:51:48.662 Last price update time: 2021.01.18 11:51:48 Volume for the current Last price: 0 Flags: 130 Changed data on the tick: - Bid price change ------ Bid price: 0.76589 Ask price: 0.76593 Last price: 0.00000 Volume for the current Last price with greater accuracy: 0.00 Spread: 0.00004 ------ Symbol: "AUDUSD" ============= End of parameter list (Tick "AUDUSD" 2021.01.18 11:51:48.662) ============= ============= Beginning of parameter list (Tick "EURUSD" 2021.01.19 10:05:07.246) ============= Last price update time in milliseconds: 2021.01.19 10:05:07.246 Last price update time: 2021.01.19 10:05:07 Volume for the current Last price: 0 Flags: 6 Changed data on the tick: - Ask price change - Bid price change ------ Bid price: 1.21189 Ask price: 1.21189 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.19 10:05:07.246) ============= ============= Beginning of parameter list (Tick "EURUSD" 2021.01.18 14:57:53.847) ============= Last price update time in milliseconds: 2021.01.18 14:57:53.847 Last price update time: 2021.01.18 14:57:53 Volume for the current Last price: 0 Flags: 134 Changed data on the tick: - Ask price change - Bid price change ------ Bid price: 1.20536 Ask price: 1.20536 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.18 14:57:53.847) =============
Como podemos observar, hemos necesitado 16 segundos para inicializar la biblioteca y crear las listas de datos de tick de dos símbolos. Luego, al recibir un tick nuevos, hemos encontrado dos ticks para cada uno de los símbolos usados (con el precio máximo Ask y el precio mínimo Bid durante el día actual).
¿Qué es lo próximo?
En el siguiente artículo, procederemos a la creación de las actualizaciones en tiempo real y al control de los eventos de datos en la colección de ticks que hemos creado en este artículo.
Más abajo se adjuntan todos los archivos de la versión actual de la biblioteca y el archivo del asesor de prueba para MQL5. Puede descargarlo todo y ponerlo a prueba por sí mismo.
Cabe mencionar que la clase de colección de datos de tick se encuentran en el proceso de desarrollo. Por tanto, no se recomienda usarla en sus programas en esta fase.
Si tiene preguntas, observaciones o sugerencias, podrá concretarlas en los comentarios al artículo.
Artículos de esta serie:
Trabajando con las series temporales en la biblioteca DoEasy (Parte 35): El objeto "Barra" y la lista de serie temporal del símbolo
Trabajando con las series temporales en la biblioteca DoEasy (Parte 36): El objeto de series temporales de todos los periodos utilizados del símbolo
Trabajando con las series temporales en la biblioteca DoEasy (Parte 37): Colección de series temporales - Base de datos de series temporales según el símbolo y el periodo
Trabajando con las series temporales en la biblioteca DoEasy (Parte 38): Colección de series temporales - Actualización en tiempo real y acceso a los datos desde el programa
Trabajando con las series temporales en la biblioteca DoEasy (Parte 39): Indicadores basados en la biblioteca - Preparación de datos y eventos de la series temporales
Trabajando con las series temporales en la biblioteca DoEasy (Parte 40): Indicadores basados en la biblioteca - actualización de datos en tiempo real
Trabajando con las series temporales en la biblioteca DoEasy (Parte 41): Ejemplo de indicador de símbolo y periodo múltiples
Trabajando con las series temporales en la biblioteca DoEasy (Parte 42): La clase del objeto de búfer de indicador abstracto
Trabajando con las series temporales en la biblioteca DoEasy (Parte 43): Las clases de los objetos de búferes de indicador
Trabajando con las series temporales en la biblioteca DoEasy (Parte 44): Las clases de colección de los objetos de búferes de indicador
Trabajando con las series temporales en la biblioteca DoEasy (Parte 45): Búferes de indicador de periodo múltiple
Trabajando con las series temporales en la biblioteca DoEasy (Parte 46): Búferes de indicador de periodo y símbolos múltiples
Trabajando con las series temporales en la biblioteca DoEasy (Parte 47): Indicadores estándar de periodo y símbolo múltiples
Trabajando con las series temporales en la biblioteca DoEasy (Parte 48): Indicadores de periodo y símbolo múltiples en un búfer en una subventana
Trabajando con las series temporales en la biblioteca DoEasy (Parte 49): Indicadores estándar de periodo, símbolo y búfer múltiples
Trabajando con las series temporales en la biblioteca DoEasy (Parte 50): Indicadores estándar de periodo y símbolo múltiples con desplazamiento
Trabajando con las series temporales en la biblioteca DoEasy (Parte 51): Indicadores estándar compuestos de período y símbolo múltiples
Trabajando con las series temporales en la biblioteca DoEasy (Parte 52): Concepto multiplataforma de indicadores estándar de periodo y símbolo múltiples de búfer único
Trabajando con las series temporales en la biblioteca DoEasy (Parte 53): Clase del indicador abstracto básico
Trabajando con las series temporales en la biblioteca DoEasy (Parte 54): Clases herederas del indicador abstracto básico
Trabajando con las series temporales en la biblioteca DoEasy (Parte 55): Clase de colección de indicadores
Trabajando con las series temporales en la biblioteca DoEasy (Parte 56): Objeto del indicador personalizado, obtención de datos de parte de los objetos de indicador en la colección
Trabajando con las series temporales en la biblioteca DoEasy (Parte 57): Objeto de datos del búfer de indicador
Trabajando con las series temporales en la biblioteca DoEasy (Parte 58): Series temporales de los datos de búferes de indicadores
Trabajando con los precios en la biblioteca DoEasy (Parte 59): Objeto para almacenar los datos de un tick
Trabajando con los precios en la biblioteca DoEasy (Parte 60): Lista de serie de datos de tick del símbolo
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/8952
Desarrollando un algoritmo de autoadaptación (Parte II): Aumentando la efectividad
Trabajando con los precios en la biblioteca DoEasy (Parte 60): Lista de serie de datos de tick del símbolo
Trabajando con los precios en la biblioteca DoEasy (Parte 62): Actualización de las series de tick en tiempo real, preparando para trabajar con la Profundidad del mercado
Desarrollando un algoritmo de autoadaptación (Parte I): Encontrando un patrón básico
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso