Trabajando con los precios en la biblioteca DoEasy (Parte 61): Colección de series de tick de los símbolos

26 marzo 2021, 12:38
Artyom Trishkin
0
101

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.

Volver al contenido

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 Software Corp.
Artículo original: https://www.mql5.com/ru/articles/8952

Archivos adjuntos |
MQL5.zip (3876.08 KB)
Desarrollando un algoritmo de autoadaptación (Parte II): Aumentando la efectividad Desarrollando un algoritmo de autoadaptación (Parte II): Aumentando la efectividad
En este artículo, continuaremos el tema del anterior. No obstante, primero flexibilizaremos el algoritmo desarrollado anteriormente. El algoritmo se ha vuelto más estable, con un aumento en el número de velas en la ventana de análisis o con un aumento en el porcentaje del umbral del preponderancia de velas descendentes o ascendentes. Hemos tenido que llegar a un compromiso y establecer un tamaño de muestra más grande para el análisis o un porcentaje mayor de preponderancia de la vela predominante.
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 60): Lista de serie de datos de tick del símbolo
En este artículo, vamos a crear una lista para almacenar los datos de tick del símbolo único, después, verificaremos su creación y obtención de los datos requeridos en el Asesor Experto. Dichas listas —siendo aplicada cada una de ellas para cada símbolo usado— van a componer luego la colección de datos de tick.
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 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
En este artículo, vamos a desarrollar la actualización de la colección de datos de tick en tiempo real, y prepararemos una clase del objeto de símbolo para manejar la Profundidad del mercado, con la que empezaremos a trabajar a partir del siguiente artículo.
Desarrollando un algoritmo de autoadaptación (Parte I): Encontrando un patrón básico Desarrollando un algoritmo de autoadaptación (Parte I): Encontrando un patrón básico
En la presente serie de artículos, mostraremos un ejemplo de desarrollo de algoritmos autoadaptativos que tengan en cuenta los factores máximos que surgen en los mercados. Asimismo, veremos la sistematización de estas situaciones, su descripción dentro de una lógica y su consideración a la hora de comerciar. Comenzaremos con un algoritmo muy simple, que con el tiempo adquirirá su propia teoría y evolucionará hasta convertirse en un proyecto muy complejo.