Descargar MetaTrader 5

Creación de un panel de información mediante las clases de la Librería estándar y Google Chart API

18 diciembre 2013, 08:11
Евгений
0
804


Introducción

Para hacer la vida más fácil a los programadores del lenguaje MQL5, los diseñadores han creado una Librería estándar, que cubre la mayoría de las funciones API MQL5, y hace que su utilización sea mucho más fácil y oportuna. En este artículo trataremos de crear un panel de información, con el máximo número de clases que utiliza la Librería estándar.


1. Resumen de las clases de la Librería estándar

¿Por tanto, qué es exactamente esta Librería? La sección de Documentación de los estados de los sitios web está formada por:

Los archivos que contienen todo tipo de clases, están ubicados en la carpeta MQL5/Include. Al ver el código de la Librería, se dará cuenta de que proporciona únicamente las clases, pero no las funciones. En consecuencia, para usarlas, hay que tener algunos conocimientos de programación orientada a objetos (POO). 

Todas las clases de la Librería (excepto las del trading) proceden de la clase básica CObject. Para mostrarla, intentaremos construir un Diagrama de clase, ya que disponemos de todo lo necesario para ello; la clase base y las que y sus derivadas. Puesto que el lenguaje MQL5 es básicamente un subconjunto de C++, vamos a usar el instrumento IBM Rational Rose, que proporciona las herramientas para la ingeniería inversa de los proyectos de C++, con el fin de llevar a cabo la construcción automática del diagrama.

 

Figura 1. Diagrama de las clases de la Librería estándar

No vamos a mostrar las propiedades y métodos de las clases, ya que los diagramas que vamos a obtener serían muy voluminosos. Tampoco vamos a ver las agregaciones, ya que no nos importan. Como resultado, nos quedamos sólo con generalizaciones (herencias), que nos permiten averiguar cuáles son las propiedades y métodos de adquisición de las clases.

Como puede verse en el diagrama, todos los componentes de la Librería que trabajan con cadenas, archivos, gráficos, objetos gráficos, y matrices, tienen su propia clase base (CString, CFile, CChart, CChartObject y CArray, respectivamente), heredadas de CObject. La clase base para trabajar con indicadores CIndicator y su clase adicional CIndicators son heredadas de CArrayObj, mientras que la clase para el acceso al buffer del indicador CIndicatorBuffer es heredada de CArrayDouble.

El color carmesí del diagrama indica que en estas clases no existen indicators ni arrays ni ChartObjects; que son conjuntos que incluyen clases para indicadores, matrices y objetos gráficos. Puesto que hay un gran número y se heredan de un único origen, me he permitido realizar alguna simplificación, para no saturar el diagrama. Por ejemplo, el indicador incluye CiDEMA, CiStdDev, etc.

Además, vale la pena destacar que se puede también realizar el diagrama de la clase mediante el sistema de creación automática de documentación Doxygen. Es un poco más fácil hacerlo con este sistema que con el Rational Rose. Se puede encontrar más información acerca de Doxygen en el artículo Generación automática de documentación para el código MQL5.


2. Descripción del problema

Vamos a tratar de crear un panel de informaciones con el máximo número de clases de la Librería estándar.

¿Qué aparecerá en el panel? Algo parecido a un informe detallado de MetaTrader 5, es decir:

Figura 2. Captura de un informe detallado

Figura 2. Captura de un informe detallado

Como podemos observar, el informe muestra un diagrama de balance y algunos datos de trading. Se puede encontrar más información acerca de los métodos de cálculo de estos indicadores en el artículo Lo que indican de los números en el informe de la prueba del Experto.

Puesto que el panel tiene un carácter meramente informativo, y no realiza ninguna transacción, sería mejor implementarlo como indicador en una ventana separada, para evitar el cierre del gráfico actual. Además, poner el panel en una ventana secundaria permite ajustarla más fácilmente, e incluso con un sólo movimiento del ratón.

No estaría de más añadir al informe una gráfica circular, que mostrará la cantidad de transacciones realizadas en el instrumento relativa al número total de transacciones.


3. Diseño de la interfaz 

Ya están definidos los objetivos; necesitamos un informe detallado en una subventana del gráfico principal.

Implementamos nuestro panel de informaciones como una clase. Empecemos:

//+------------------------------------------------------------------+
///The Board class
//+------------------------------------------------------------------+
class Board
  {
//protected data
protected:
///number of the sub-window where the board will be stored
   int               wnd;             
///array with the deals data   
   CArrayObj        *Data;
///array with the balance data   
   CArrayDouble      ChartData;       
///array with elements of the interface   
   CChartObjectEdit  cells[10][6];    
///object for working with the chart   
   CChart            Chart;           
///object for working with the balance chart
   CChartObjectBmpLabel BalanceChart; 
///object for working with the pie chart
   CChartObjectBmpLabel PieChart;     
///data for the pie chart
   PieData          *pie_data;
//private data and methods
private:
   double            net_profit;      //these variables will store the calculated characteristics
   double            gross_profit;
   double            gross_loss;
   double            profit_factor;
   double            expected_payoff;
   double            absolute_drawdown;
   double            maximal_drawdown;
   double            maximal_drawdown_pp;
   double            relative_drawdown;
   double            relative_drawdown_pp;
   int               total;
   int               short_positions;
   double            short_positions_won;
   int               long_positions;
   double            long_positions_won;
   int               profit_trades;
   double            profit_trades_pp;
   int               loss_trades;
   double            loss_trades_pp;
   double            largest_profit_trade;
   double            largest_loss_trade;
   double            average_profit_trade;
   double            average_loss_trade;
   int               maximum_consecutive_wins;
   double            maximum_consecutive_wins_usd;
   int               maximum_consecutive_losses;
   double            maximum_consecutive_losses_usd;
   int               maximum_consecutive_profit;
   double            maximum_consecutive_profit_usd;
   int               maximum_consecutive_loss;
   double            maximum_consecutive_loss_usd;
   int               average_consecutive_wins;
   int               average_consecutive_losses;

   ///method of obtaining data about the deals and the balance
   void              GetData();

   ///method of calculating the characteristics
   void              Calculate();
   
   ///method of chart construction
   void              GetChart(int X_size,int Y_size,string request,string file_name);
   
   ///method of request to Google Charts API
   string            CreateGoogleRequest(int X_size,int Y_size,bool type);
   
  ///method of obtaining the optimum font size
   int               GetFontSize(int x,int y);
   string            colors[12];  //array with text presentation of colors
//public methods
public:
///constructor
   void              Board();    
///destructor         
   void             ~Board();    
///method for board update
   void              Refresh();  
///method for creating interface elements   
   void              CreateInterface(); 
  };

Los datos protegidos de la clase son los elementos y transacciones de la interfaz, el balance, y los datos del gráfico circular (más adelante hablaremos de la clase PieData). Los indicadores de trading y algunos métodos son privados. Son privados porque el usuario no debe tener acceso directo a ellos, se calculan en la clase, y solo se pueden calcular mediante la llamada al método público adecuado. 

Los métodos de creación de la interfaz y del cálculo de los indicadores son también privados, puesto que se debe seguir una rigurosa secuencia de métodos de llamadas. Por ejemplo, es imposible calcular los indicadores sin disponer de datos para el cálculo, o actualizar la interfaz sin haberla creado antes. Por lo tanto, no vamos a permitir al usuario "pegarse un tiro". 

En seguida vamos a abordar los constructores y destructores de clases, y no tenemos que volver a verlos más adelante:

//+------------------------------------------------------------------+
///Constructor
//+------------------------------------------------------------------+
void Board::Board()
  {
   Chart.Attach();                               //attach the current chart to the class instance
   wnd=ChartWindowFind(Chart.ChartId(),"IT");    //find the indicator window
   Data = new CArrayObj;                         //creating the CArrayObj class instance
   pie_data=new PieData;                         //creating the PieData class instance
   //fill colors array
   colors[0]="003366"; colors[1]="00FF66"; colors[2]="990066";
   colors[3]="FFFF33"; colors[4]="FF0099"; colors[5]="CC00FF";
   colors[6]="990000"; colors[7]="3300CC"; colors[8]="000033";
   colors[9]="FFCCFF"; colors[10]="CC6633"; colors[11]="FF0000";
  }
//+------------------------------------------------------------------+
///Destructor
//+------------------------------------------------------------------+
void Board::~Board()
  {
   if(CheckPointer(Data)!=POINTER_INVALID) delete Data;   //delete the deals data
   if(CheckPointer(pie_data)!=POINTER_INVALID) delete pie_data;
   ChartData.Shutdown();    //and balance data
   Chart.Detach();          //detach from the chart
   for(int i=0;i<10;i++)    //delete all interface elements
      for(int j=0;j<6;j++)
         cells[i][j].Delete();
   BalanceChart.Delete();   //delete the balance chart
   PieChart.Delete();       //and pie chart
  }

En el constructor, uniremos un objeto del tipo CChart al gráfico actual con la ayuda de su método Attach(). El método Detach(), al que se llama en el destructor, separará el gráfico del objeto. El objeto Data, es un puntero a un objeto de tipo CArrayObj, recibirá la dirección del objeto, que se crea de manera dinámica mediante la operación new y se borra en el destructor mediante la operación delete. No hay que olvidarse de comprobar la presencia de datos usando el CheckPointer() antes de borrar, de lo contrario, se producirá un error.

Se proporcionará más información acerca de la clase CArrayObj más adelante. El método Shutdown() de la clase CArrayDouble como cualquier otra clase es heredado de la clase CArray (ver el diagrama de clases) borrará y liberará la memoria ocupada por el objeto. El método Delete() heredado de la clase CChartObject elimina el objeto del gráfico.

Por lo tanto, el constructor asigna la memoria y el destructor la libera y elimina los objetos gráficos creados por la clase. 

Vamos a ver ahora la interfaz. Como se ha indicado anteriormente, el método CreateInterface() crea la interfaz del panel:

//+------------------------------------------------------------------+
///CreateInterface function
//+------------------------------------------------------------------+
void Board::CreateInterface()
  {
   //retrieve the width
   int x_size=Chart.WidthInPixels();
   //and the height of the indicator window
   int y_size=Chart.GetInteger(CHART_HEIGHT_IN_PIXELS,wnd);
   
    //calculate, how much space will the balance chart take up
   double chart_border=y_size*(1.0-(Chart_ratio/100.0));

   if(Chart_ratio<100)//if the balance chart is taking up the entire table
     {
      for(int i=0;i<10;i++)//create columns
        {
         for(int j=0;j<6;j++)//and rows
           {
            cells[i][j].Create(Chart.ChartId(),"InfBoard "+IntegerToString(i)+" "+IntegerToString(j),
                               wnd,j*(x_size/6.0),i*(chart_border/10.0),x_size/6.0,chart_border/10.0);
            //set selectable property to false
            cells[i][j].Selectable(false);
            //set text as read only
            cells[i][j].ReadOnly(true);
            //set font size
            cells[i][j].FontSize(GetFontSize(x_size/6.0, chart_border/10.0));
            cells[i][j].Font("Arial");    //font name
            cells[i][j].Color(text_color);//font color
           }
        }
     }

   if(Chart_ratio>0)//if the balance chart is required
     {
      //create a balance chart
      BalanceChart.Create(Chart.ChartId(), "InfBoard chart", wnd, 0, chart_border);
      //set selectable property to false
      BalanceChart.Selectable(false);
      //create a pie chart
      PieChart.Create(Chart.ChartId(), "InfBoard pie_chart", wnd, x_size*0.75, chart_border);
      PieChart.Selectable(false);//set selectable property to false
     }

   Refresh();//refresh the board
  }

Para una disposición compacta de todos los elementos, primero, mediante los métodos WidthInPixels() y GetInteger() de la clase CChart, averiguamos la altura y el ancho de la subventana del indicador dónde se ubicará el panel. A continuación, creamos las celdas que van a contener los valores de los indicadores, mediante el método Create() de la clase CChartObjectEdit (crea el "campo de entrada"; input field), todas las clases heredadas tienen este método de CChartObject.

Cabe destacar lo cómodo que es usar la Librería estándar para operaciones de este tipo. Sin ella hubiéramos tenido que crear cada objeto, mediante la función PbjectCreate, y definir las propiedades de los objetos, mediante funciones como ObjectSet, lo que llevaría a la redundancia del código. Y si más adelante queremos modificar las propiedades de los objetos, habrá que comprobar cuidadosamente los nombres de los objetos para evitar confusiones. Ahora podemos sencillamente crear una matriz de objetos, y consultarla como queramos.

Además, podemos obtener o definir las propiedades de los objetos de una función, si se sobrecarga mediante los creadores de la clase, como el método Color() de la clase CChartObject. Si se le llama con los parámetros, los establece, y sin parámetros devuelve el color del objeto. Además, coloca el gráfico circular cerca del gráfico de balance, ocupando la cuarta parte del ancho total de la pantalla.

La actualización de method() actualiza el panel. ¿En qué consiste esta actualización? Tenemos que calcular los indicadores, agregarlos a los objetos gráficos y redimensionar el panel, en el caso de que haya cambiado el tamaño de su ventana. El panel debe ocupar todo el espacio libre de la ventana.

//+------------------------------------------------------------------+
///Function of the board updating
//+------------------------------------------------------------------+
void Board::Refresh()
  {
   //check the server connection status
   if(!TerminalInfoInteger(TERMINAL_CONNECTED)) {Alert("No connection with the trading server!"); return;}
   //check the permission for importing functions from DLL
   if(!TerminalInfoInteger(TERMINAL_DLLS_ALLOWED)) {Alert("DLLs are prohibited!"); return;}
   //calculate the characteristics
   Calculate();
   //retrieve the width
   int x_size=Chart.WidthInPixels();
   //and the height of the indicator window
   int y_size=Chart.GetInteger(CHART_HEIGHT_IN_PIXELS,wnd);
   //calculate how much space the balance chart will take up
   double chart_border=y_size*(1.0-(Chart_ratio/100.0));

   string captions[10][6]= //array with signatures of interface elements
     {
        {"Total Net Profit:"," ","Gross Profit:"," ","Gross Loss:"," "},
        {"Profit Factor:"," ","Expected Payoff:"," ","",""},
        {"Absolute Drawdown:"," ","Maximal Drawdown:"," ","Relative Drawdown:"," "},
        {"Total Trades:"," ","Short Positions (won %):"," ","Long Positions (won %):"," "},
        {"","","Profit Trades (% of total):"," ","Loss trades (% of total):"," "},
        {"Largest","","profit trade:"," ","loss trade:"," "},
        {"Average","","profit trade:"," ","loss trade:"," "},
        {"Maximum","","consecutive wins ($):"," ","consecutive losses ($):"," "},
        {"Maximal","","consecutive profit (count):"," ","consecutive loss (count):"," "},
        {"Average","","consecutive wins:"," ","consecutive losses:"," "}
     };

   //put the calculated characteristics into the array
   captions[0][1]=DoubleToString(net_profit, 2);
   captions[0][3]=DoubleToString(gross_profit, 2);
   captions[0][5]=DoubleToString(gross_loss, 2);

   captions[1][1]=DoubleToString(profit_factor, 2);
   captions[1][3]=DoubleToString(expected_payoff, 2);

   captions[2][1]=DoubleToString(absolute_drawdown, 2);
   captions[2][3]=DoubleToString(maximal_drawdown, 2)+"("+DoubleToString(maximal_drawdown_pp, 2)+"%)";
   captions[2][5]=DoubleToString(relative_drawdown_pp, 2)+"%("+DoubleToString(relative_drawdown, 2)+")";

   captions[3][1]=IntegerToString(total);
   captions[3][3]=IntegerToString(short_positions)+"("+DoubleToString(short_positions_won, 2)+"%)";
   captions[3][5]=IntegerToString(long_positions)+"("+DoubleToString(long_positions_won, 2)+"%)";

   captions[4][3]=IntegerToString(profit_trades)+"("+DoubleToString(profit_trades_pp, 2)+"%)";
   captions[4][5]=IntegerToString(loss_trades)+"("+DoubleToString(loss_trades_pp, 2)+"%)";

   captions[5][3]=DoubleToString(largest_profit_trade, 2);
   captions[5][5]=DoubleToString(largest_loss_trade, 2);

   captions[6][3]=DoubleToString(average_profit_trade, 2);
   captions[6][5]=DoubleToString(average_loss_trade, 2);

   captions[7][3]=IntegerToString(maximum_consecutive_wins)+"("+DoubleToString(maximum_consecutive_wins_usd, 2)+")";
   captions[7][5]=IntegerToString(maximum_consecutive_losses)+"("+DoubleToString(maximum_consecutive_losses_usd, 2)+")";

   captions[8][3]=DoubleToString(maximum_consecutive_profit_usd, 2)+"("+IntegerToString(maximum_consecutive_profit)+")";
   captions[8][5]=DoubleToString(maximum_consecutive_loss_usd, 2)+"("+IntegerToString(maximum_consecutive_loss)+")";

   captions[9][3]=IntegerToString(average_consecutive_wins);
   captions[9][5]=IntegerToString(average_consecutive_losses);

   if(Chart_ratio<100) //if the balance chart doesn't take up the entire table
     {
      for(int i=0;i<10;i++) //go through the interface elements
        {
         for(int j=0;j<6;j++)
           {
            //specify the position
            cells[i][j].X_Distance(j*(x_size/6.0));
            cells[i][j].Y_Distance(i*(chart_border/10.0));
            //the size
            cells[i][j].X_Size(x_size/6.0);
            cells[i][j].Y_Size(chart_border/10.0);
            //the text
            cells[i][j].SetString(OBJPROP_TEXT,captions[i][j]);
            //and font size
            cells[i][j].FontSize(GetFontSize(x_size/6.0,chart_border/10.0));
           }
        }
     }

   if(Chart_ratio>0)//if the balance chart is required
     {
      //refresh the balance chart
      int X=x_size*0.75,Y=y_size-chart_border;
      //get the chart
      GetChart(X,Y,CreateGoogleRequest(X,Y,true),"board_balance_chart");
      //set its position
      BalanceChart.Y_Distance(chart_border);
      //specify file names
      BalanceChart.BmpFileOn("board_balance_chart.bmp");
      BalanceChart.BmpFileOff("board_balance_chart.bmp");
      //refresh the pie chart
      X=x_size*0.25;
      //get the chart
      GetChart(X,Y,CreateGoogleRequest(X,Y,false),"pie_chart");
      //set its new position
      PieChart.Y_Distance(chart_border);
      PieChart.X_Distance(x_size*0.75);
      //specify file names
      PieChart.BmpFileOn("pie_chart.bmp");
      PieChart.BmpFileOff("pie_chart.bmp");
     }

   ChartRedraw(); //redraw the chart
  }

Hay muchos códigos, parecidos al método CreateInterface(), primero la función Calculate() calcula los indicadores, después se introducen en los objetos gráficos, y al mismo tiempo se adaptan los tamaños de los objetos a los tamaños de las ventanas, mediante los métodos X_Size() y Y_Size(). Los métodos X_Distance e Y_Distance cambian la posición del objeto.

Preste atención a la función GetFontSize() que selecciona el tamaño de la fuente, de modo que no haya "desbordamiento" del texto fuera de su área después de cambiar su dimensión y, por otro lado, que no se haga demasiado pequeño.

Echemos un vistazo a esta función de cerca:

//import DLL function for string metrics
#import "String_Metrics.dll" 
void GetStringMetrics(int font_size,int &X,int &Y);
#import

//+------------------------------------------------------------------+
///Function of determining the optimum font size
//+------------------------------------------------------------------+
int Board::GetFontSize(int x,int y)
  {
   int res=8;
   for(int i=15;i>=1;i--)//go through the different font sizes
     {
      int X,Y; //here we input the line metrics
      //determine the metrics
      GetStringMetrics(i,X,Y);
      //if the line fits the set borders - return the font size
      if(X<=x && Y<=y) return i;
     }
   return res;
  } 

Se ha importado la función GetStringMetrics() desde la DLL, se puede encontrar su código descrito más arriba en el archivo DLL_Sources.zip y se puede modificar si es necesario. Creo que puede resultar muy útil si decide diseñar su propia interfaz en el proyecto.

Hemos finalizado la interfaz de usuario, vamos a volver al cálculo de los indicadores de trading.


4. Cálculo de los indicadores de trading

El método Calculate() realiza los cálculos.

Pero necesitamos también el método GetData(), que recibe los datos necesarios:

//+------------------------------------------------------------------+
///Function of receiving the deals and balance data
//+------------------------------------------------------------------+
void Board::GetData()
  {
   //delete old data
   Data.Shutdown();
   ChartData.Shutdown();
   pie_data.Shutdown();
   //prepare all the deals history
   HistorySelect(0,TimeCurrent()); 
   CAccountInfo acc_inf;   //object for work with account
   //calculate the balance
   double balance=acc_inf.Balance();
   double store=0; //balance
   long_positions=0;
   short_positions=0;
   long_positions_won=0;
   short_positions_won=0;
   for(int i=0;i<HistoryDealsTotal();i++) //go through all of the deals in the history

     {
      CDealInfo deal;  //the information about the deals will be stored here
      deal.Ticket(HistoryDealGetTicket(i));//get deal ticket
      //if the trade had a financial result (exit of the market)
      if(deal.Ticket()>=0 && deal.Entry()==DEAL_ENTRY_OUT)
        {
         pie_data.Add(deal.Symbol()); //add data for the pie chart
         //check for the symbol 
         if(!For_all_symbols && deal.Symbol()!=Symbol()) continue;
         double profit=deal.Profit(); //retrieve the trade profit
         profit+=deal.Swap();         //swap
         profit+=deal.Commission();   //commission
         store+=profit;               //cumulative profit
         Data.Add(new CArrayDouble);  //add new element to the array
         ((CArrayDouble *)Data.At(Data.Total()-1)).Add(profit);  //and data
         ((CArrayDouble *)Data.At(Data.Total()-1)).Add(deal.Type());
        }
     }

   //calculate the initial deposit
   double initial_deposit=(balance-store);
   for(int i=0;i<Data.Total();i++) //go through the prepared trades
     {
      //calculate the balance value
      initial_deposit+=((CArrayDouble *)Data.At(i)).At(0);
      ChartData.Add(initial_deposit); //and put it to the array
     }
  }

Primero, vamos a ver el método de almacenamiento de datos. La Librería estándar proporciona las clases de estructuras de datos, que le permiten prescindir de las matrices. Necesitamos una matriz de dos dimensiones, en la cual almacenaremos los datos de los beneficios y el tipo de transacciones del historial. Pero la Librería estándar no proporciona clases explícitas para la organización de matrices de dos dimensiones, sin embargo, están las clases CArrayDouble (matriz de datos de tipo doble) y CArrayObj (matriz dinámica de punteros a las instancias de la clase CObject y sus herederas). Es decir, podemos crear una matriz de matrices de tipo doble, y esto es exactamente lo que se hace. 

Desde luego, los declaraciones tipo ((CArrayDouble *) Data.At (Data.Total () - 1 )).Add (profit) no se ven tan claras como data [i] [j] = profit, pero sólo a primera vista. Después de todo, con una simple declaración de una matriz y si no usamos las clases de la Librería estándar, no tendremos algunas ventajas, como el administrador integrado de memoria, la capacidad de insertar una matriz diferente, comparar matrices, buscar elementos, etc. Por lo tanto, el uso de las clases de organización de memoria nos libera de la necesidad de controlar el desbordamiento de la matriz, y nos proporciona muchos instrumentos útiles. 

El método Total() de la clase CArray (ver Fig. 1.) devuelve el número de elementos en la matriz, el método Add() los añade y el método At() devuelve los elementos.

Puesto que hemos decidido crear un gráfico circular, vamos a necesitar recoger los datos necesarios para poder mostrar el número de transacciones de símbolos.

Vamos a escribir una clase adicional, destinada a recoger estos datos:

//+------------------------------------------------------------------+
///The Pie chart class
//+------------------------------------------------------------------+
class PieData
  {
protected:
///number of deals per symbol
   CArrayInt         val;   
///symbols
   CArrayString      symb;  
public:
///delete the data
   bool Shutdown()          
     {
      bool res=true;
      res&=val.Shutdown();
      res&=symb.Shutdown();
      return res;
     }
///search for a sting in the array
   int Search(string str)   
     {  //check all array elements
      for(int i=0;i<symb.Total();i++)
         if(symb.At(i)==str) return i;
      return -1;
     }
///add new data
   void Add(string str)    
     {
      int symb_pos=Search(str);//determine symbol position in the array
      if(symb_pos>-1)
         val.Update(symb_pos,val.At(symb_pos)+1);//update the deals data
      else //if there isn't such a symbol yet
        {
         symb.Add(str); //add it
         val.Add(1);
        }
     }

   int Total() const {return symb.Total();}
   int Get_val(int pos) const {return val.At(pos);}
   string Get_symb(int pos) const {return symb.At(pos);}
  };

Las clases de la Librería estándar no son siempre capaces de proporcionarnos los métodos necesarios para trabajar. En este ejemplo, el método Search() de la clase CArrayString no es adecuado, ya que para poder aplicarlo, primero tenemos que ordenar la matriz, cosa que viola la estructura de los datos. Por lo tanto, tenemos que escribir nuestro propio método.

Se implementa el cálculo de los datos de la operación de trading en el método Calculate():

//+------------------------------------------------------------------+
///Calculation of characteristics
//+------------------------------------------------------------------+
void Board::Calculate()
  {
   //get the data
   GetData();
   //zero all characteristics
   gross_profit=0;
   gross_loss=0;
   net_profit=0;
   profit_factor=0;
   expected_payoff=0;
   absolute_drawdown=0;
   maximal_drawdown_pp=0;
   maximal_drawdown=0;
   relative_drawdown=0;
   relative_drawdown_pp=0;
   total=Data.Total();
   long_positions=0;
   long_positions_won=0;
   short_positions=0;
   short_positions_won=0;
   profit_trades=0;
   profit_trades_pp=0;
   loss_trades=0;
   loss_trades_pp=0;
   largest_profit_trade=0;
   largest_loss_trade=0;
   average_profit_trade=0;
   average_loss_trade=0;
   maximum_consecutive_wins=0;
   maximum_consecutive_wins_usd=0;
   maximum_consecutive_losses=0;
   maximum_consecutive_losses_usd=0;
   maximum_consecutive_profit=0;
   maximum_consecutive_profit_usd=0;
   maximum_consecutive_loss=0;
   maximum_consecutive_loss_usd=0;
   average_consecutive_wins=0;
   average_consecutive_losses=0;

   if(total==0) return; //there isn't deals - return from the function
   double max_peak=0,min_peak=0,tmp_balance=0;
   int max_peak_pos=0,min_peak_pos=0;
   int max_cons_wins=0,max_cons_losses=0;
   double max_cons_wins_usd=0,max_cons_losses_usd=0;
   int avg_win=0,avg_loss=0,avg_win_cnt=0,avg_loss_cnt=0;

   for(int i=0; i<total; i++)
     {
      double profit=((CArrayDouble *)Data.At(i)).At(0); //get profit
      int deal_type=((CArrayDouble *)Data.At(i)).At(1); //and deal type
      switch(deal_type) //check deal type
        {
         //and calculate number of long and short positions
         case DEAL_TYPE_BUY: {long_positions++; if(profit>=0) long_positions_won++; break;}
         case DEAL_TYPE_SELL: {short_positions++; if(profit>=0) short_positions_won++; break;}
        }

      if(profit>=0)//the deal is profitable
        {
         gross_profit+=profit; //gross profit
         profit_trades++;      //number of profit deals
         //the largest profitable trade and the largest profitable series
         if(profit>largest_profit_trade) largest_profit_trade=profit;

         if(maximum_consecutive_losses<max_cons_losses || 
            (maximum_consecutive_losses==max_cons_losses && maximum_consecutive_losses_usd>max_cons_losses_usd))
           {
            maximum_consecutive_losses=max_cons_losses;
            maximum_consecutive_losses_usd=max_cons_losses_usd;
           }
         if(maximum_consecutive_loss_usd>max_cons_losses_usd || 
            (maximum_consecutive_loss_usd==max_cons_losses_usd && maximum_consecutive_losses<max_cons_losses))
           {
            maximum_consecutive_loss=max_cons_losses;
            maximum_consecutive_loss_usd=max_cons_losses_usd;
           }
         //average profit per deal
         if(max_cons_losses>0) {avg_loss+=max_cons_losses; avg_loss_cnt++;}
         max_cons_losses=0;
         max_cons_losses_usd=0;
         max_cons_wins++;
         max_cons_wins_usd+=profit;
        }
      else //deal is losing
        {
         gross_loss-=profit; //cumulative profit
         loss_trades++;      //number of losing deals
         //the most unprofitable deal and the most unprofitable series
         if(profit<largest_loss_trade) largest_loss_trade=profit;
         if(maximum_consecutive_wins<max_cons_wins || 
            (maximum_consecutive_wins==max_cons_wins && maximum_consecutive_wins_usd<max_cons_wins_usd))
           {
            maximum_consecutive_wins=max_cons_wins;
            maximum_consecutive_wins_usd=max_cons_wins_usd;
           }
         if(maximum_consecutive_profit_usd<max_cons_wins_usd || 
            (maximum_consecutive_profit_usd==max_cons_wins_usd && maximum_consecutive_profit<max_cons_wins))
           {
            maximum_consecutive_profit=max_cons_wins;
            maximum_consecutive_profit_usd=max_cons_wins_usd;
           }
         //average lose per deal
         if(max_cons_wins>0) {avg_win+=max_cons_wins; avg_win_cnt++;}
         max_cons_wins=0;
         max_cons_wins_usd=0;
         max_cons_losses++;
         max_cons_losses_usd+=profit;
        }

      tmp_balance+=profit; //absolute drawdown calculation
      if(tmp_balance>max_peak) {max_peak=tmp_balance; max_peak_pos=i;}
      if(tmp_balance<min_peak) {min_peak=tmp_balance; min_peak_pos=i;}
      if((max_peak-min_peak)>maximal_drawdown && min_peak_pos>max_peak_pos) maximal_drawdown=max_peak-min_peak;
     }
   //maximal drawdown calculation
   double min_peak_rel=max_peak;
   tmp_balance=0;
   for(int i=max_peak_pos;i<total;i++)
     {
      double profit=((CArrayDouble *)Data.At(i)).At(0);
      tmp_balance+=profit;
      if(tmp_balance<min_peak_rel) min_peak_rel=tmp_balance;
     }
   //relative drawdown calculation
   relative_drawdown=max_peak-min_peak_rel;
   //net profit
   net_profit=gross_profit-gross_loss;
   //profit factor
   profit_factor=(gross_loss!=0) ?  gross_profit/gross_loss : gross_profit;
   //expected payoff
   expected_payoff=net_profit/total;
   double initial_deposit=AccountInfoDouble(ACCOUNT_BALANCE)-net_profit;
   absolute_drawdown=MathAbs(min_peak); 
   //drawdowns
   maximal_drawdown_pp=(initial_deposit!=0) ?(maximal_drawdown/initial_deposit)*100.0 : 0;
   relative_drawdown_pp=((max_peak+initial_deposit)!=0) ?(relative_drawdown/(max_peak+initial_deposit))*100.0 : 0;
   
   //profit and losing trade percentage
   profit_trades_pp=((double)profit_trades/total)*100.0;
   loss_trades_pp=((double)loss_trades/total)*100.0;
   
   //average profitable and losing deals
   average_profit_trade=(profit_trades>0) ? gross_profit/profit_trades : 0;
   average_loss_trade=(loss_trades>0) ? gross_loss/loss_trades : 0;
   
   //maximum consecutive losses
   if(maximum_consecutive_losses<max_cons_losses || 
      (maximum_consecutive_losses==max_cons_losses && maximum_consecutive_losses_usd>max_cons_losses_usd))
     {
      maximum_consecutive_losses=max_cons_losses;
      maximum_consecutive_losses_usd=max_cons_losses_usd;
     }
   if(maximum_consecutive_loss_usd>max_cons_losses_usd || 
      (maximum_consecutive_loss_usd==max_cons_losses_usd && maximum_consecutive_losses<max_cons_losses))
     {
      maximum_consecutive_loss=max_cons_losses;
      maximum_consecutive_loss_usd=max_cons_losses_usd;
     }

   if(maximum_consecutive_wins<max_cons_wins || 
      (maximum_consecutive_wins==max_cons_wins && maximum_consecutive_wins_usd<max_cons_wins_usd))
     {
      maximum_consecutive_wins=max_cons_wins;
      maximum_consecutive_wins_usd=max_cons_wins_usd;
     }
   if(maximum_consecutive_profit_usd<max_cons_wins_usd || 
      (maximum_consecutive_profit_usd==max_cons_wins_usd && maximum_consecutive_profit<max_cons_wins))
     {
      maximum_consecutive_profit=max_cons_wins;
      maximum_consecutive_profit_usd=max_cons_wins_usd;
     }
   //average loss and profit
   if(max_cons_losses>0) {avg_loss+=max_cons_losses; avg_loss_cnt++;}
   if(max_cons_wins>0) {avg_win+=max_cons_wins; avg_win_cnt++;}
   average_consecutive_wins=(avg_win_cnt>0) ? round((double)avg_win/avg_win_cnt) : 0;
   average_consecutive_losses=(avg_loss_cnt>0) ? round((double)avg_loss/avg_loss_cnt) : 0;
   
   //number of profitable long and short positions
   long_positions_won=(long_positions>0) ?((double)long_positions_won/long_positions)*100.0 : 0;
   short_positions_won=(short_positions>0) ?((double)short_positions_won/short_positions)*100.0 : 0;
  }

5. El uso de Google Chart API para crear un gráfico de balance

Google Chart API permite a los desarrolladores crear diagramas de distintos tipos de forma inmediata. Se almacena Google Chart API en el enlace hacia el recurso (URL) en los servidores Web de Google y cuando recibe un enlace (URL) con el formato correcto, devuelve el diagrama en forma de imagen.

Las características del diagrama (colores, encabezados, ejes, puntos del gráfico, etc.) se especifican por el enlace (URL). Se puede almacenar la imagen resultante en un sistema de archivos o en una base de datos. Lo mejor de todo es que Google Chart API es gratuita y no requiere ni una cuenta ni completar un proceso de registro. 

El método GetChart() recibe el gráfico de Google y lo guarda en el disco:

#import "PNG_to_BMP.dll"//import of DLL with the function of conversion of PNG images to BMP
bool Convert_PNG(string src,string dst);
#import

#import "wininet.dll"//import DLL with the function for working with the internet
int InternetAttemptConnect(int x);
int InternetOpenW(string sAgent,int lAccessType,
                  string sProxyName="",string sProxyBypass="",
                  int lFlags=0);
int InternetOpenUrlW(int hInternetSession,string sUrl,
                     string sHeaders="",int lHeadersLength=0,
                     int lFlags=0,int lContext=0);
int InternetReadFile(int hFile,char &sBuffer[],int lNumBytesToRead,
                     int &lNumberOfBytesRead[]);
int InternetCloseHandle(int hInet);
#import

//+------------------------------------------------------------------+
///Function of creating a balance chart
//+------------------------------------------------------------------+
void Board::GetChart(int X_size,int Y_size,string request,string file_name)
  {
   if(X_size<1 || Y_size<1) return; //too small
   //try to create connection
   int rv=InternetAttemptConnect(0);
   if(rv!=0) {Alert("Error in call of the InternetAttemptConnect()"); return;}
   //initialize the structures
   int hInternetSession=InternetOpenW("Microsoft Internet Explorer", 0, "", "", 0);
   if(hInternetSession<=0) {Alert("Error in call of the InternetOpenW()"); return;}
   //send request
   int hURL=InternetOpenUrlW(hInternetSession, request, "", 0, 0, 0);
   if(hURL<=0) Alert("Error in call of the InternetOpenUrlW()");
   //file with the result
   CFileBin chart_file;
   //let's create it
   chart_file.Open(file_name+".png",FILE_BIN|FILE_WRITE);
   int dwBytesRead[1]; //number of data read
   char readed[1000];  //the data 
   //read the data, returned by server after the request
   while(InternetReadFile(hURL,readed,1000,dwBytesRead))
     {
      if(dwBytesRead[0]<=0) break; //no data - exit
      chart_file.WriteCharArray(readed,0,dwBytesRead[0]); //write data to file
     }
   InternetCloseHandle(hInternetSession);//close connection
   chart_file.Close();//close file
   //******************************
   //prepare the paths for the converter
   CString src;
   src.Assign(TerminalInfoString(TERMINAL_PATH));
   src.Append("\MQL5\Files\\"+file_name+".png");
   src.Replace("\\","\\\\");
   CString dst;
   dst.Assign(TerminalInfoString(TERMINAL_PATH));
   dst.Append("\MQL5\Images\\"+file_name+".bmp");
   dst.Replace("\\","\\\\");
   //convert the file
   if(!Convert_PNG(src.Str(),dst.Str())) Alert("Error in call of the Convert_PNG()");
  }
  

Puede obtener más detalles para trabajar con las herramientas API de Windows y MQL5 del artículo El uso de WinInet.dll para intercambiar datos entre terminales a través de Internet. Por lo tanto, no voy a dedicarle más tiempo. He escrito yo mismo la función importada Convert_PNG() para la conversión de imágenes PNG a BMP. 

Es necesaria, puesto que Google Chart devuelve gráficos en el formato PNG o GIF, y el objeto "graphic label" sólo acepta imágenes BMP. Se puede encontrar el código de las correspondientes funciones de la librería PNG_to_BMP.dll en el archivo DLL_Sources.zip.

Esta función muestra también algunos ejemplos de trabajo con cadenas y archivos mediante la Librería estándar. Los métodos de la clase CString permiten realizar las mismas operaciones que las funciones de cadena (String Functions). La clase CFile es la base para las clases CFileBin y CFileTxt. Con ellas podemos leer y escribir archivos binarios y de texto respectivamente. Los métodos son similares a las funciones para trabajar con archivos.

Por último, describiremos la función CreateGoogleRequest (); crea peticiones desde los datos presentes en el balance:

//+------------------------------------------------------------------+
///Function for creating a request for the Google Charts server
//+------------------------------------------------------------------+
string Board::CreateGoogleRequest(int X_size,int Y_size,bool type)
  {
   if(X_size>1000) X_size=1000; //check the chart size
   if(Y_size>1000) Y_size=300;  //to make sure it is not too large
   if(X_size<1) X_size=1;       //and small//s18>
   if(Y_size<1) Y_size=1;
   if(X_size*Y_size>300000) {X_size=1000; Y_size=300;}//and fit the area
   CString res; //string with results
   if(type) //create request for the balance chart
     {
      //prepare the request
      res.Assign("http://chart.apis.google.com/chart?cht=lc&chs=");
      res.Append(IntegerToString(X_size));
      res.Append("x");
      res.Append(IntegerToString(Y_size));
      res.Append("&chd=t:");
      for(int i=0;i<ChartData.Total();i++)
         res.Append(DoubleToString(ChartData.At(i),2)+",");
      res.TrimRight(",");
      //sort array
      ChartData.Sort();
      res.Append("&chxt=x,r&chxr=0,0,");
      res.Append(IntegerToString(ChartData.Total()));
      res.Append("|1,");
      res.Append(DoubleToString(ChartData.At(0),2)+",");
      res.Append(DoubleToString(ChartData.At(ChartData.Total()-1),2));
      res.Append("&chg=10,10&chds=");
      res.Append(DoubleToString(ChartData.At(0),2)+",");
      res.Append(DoubleToString(ChartData.At(ChartData.Total()-1),2));
     }
   else //create request for the pie chart
     {
      //prepare the request
      res.Assign("http://chart.apis.google.com/chart?cht=p3&chs=");
      res.Append(IntegerToString(X_size));
      res.Append("x");
      res.Append(IntegerToString(Y_size));
      res.Append("&chd=t:");
      for(int i=0;i<pie_data.Total();i++)
         res.Append(IntegerToString(pie_data.Get_val(i))+",");
      res.TrimRight(",");
      res.Append("&chdl=");
      for(int i=0;i<pie_data.Total();i++)
         res.Append(pie_data.Get_symb(i)+"|");
      res.TrimRight("|");
      res.Append("&chco=");
      int cnt=0;
      for(int i=0;i<pie_data.Total();i++)
        {
         if(cnt>11) cnt=0;
         res.Append(colors[cnt]+"|");
         cnt++;
        }
      res.TrimRight("|");
     }
   return res.Str(); //return the result
  } 

Cabe señalar que las peticiones para el gráfico de balance y el gráfico circular se recogen por separado. El método Append() añade otra cadena después de la última y el método TrimRight() le permite eliminar los caracteres extra, que aparecen al final de cada línea.


6. El ensamblaje final y las pruebas

La clase está lista, vamos a probarla. Vamos a empezar con el indicador OnInit (): 

Board *tablo;   //pointer to the board object
int prev_x_size=0,prev_y_size=0,prev_deals=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   //set indicator short name
   IndicatorSetString(INDICATOR_SHORTNAME,"IT");
   //launch the timer
   EventSetTimer(1); 
   //create object instance
   tablo=new Board;
   //and the interface
   tablo.CreateInterface(); 
   prev_deals=HistoryDealsTotal(); //number of deals
   //current sizes of the window
   prev_x_size=ChartGetInteger(0,CHART_WIDTH_IN_PIXELS); 
   prev_y_size=ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
//---
   return(0);
  }

Aquí, creamos de forma dinámica la instancia de clase del Panel, iniciamos el temporizador e inicializamos las variables adicionales. 

A continuación colocamos la función OnDeinit(), en la cual eliminamos el objeto (que llama automáticamente al destructor) y detenemos el temporizador:

void OnDeinit(const int reason)
{
   EventKillTimer(); //stop the timer
   delete table;    //and board
}

La función OnCalculate() va a realizar un seguimiento del flujo de las nuevas transacciones, tick por tick, y actualizar la pantalla, si esto sucede: 

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   //prepare the history
   HistorySelect(0,TimeCurrent());
   int deals=HistoryDealsTotal();
   //update the board if number of deals has changed
   if(deals!=prev_deals) tablo.Refresh();
   prev_deals=deals;
//--- return value of prev_calculated for next call
   return(rates_total);
  }

La función OnTimer() hace el seguimiento de los cambios de tamaño de la ventana y, si es necesario, adapta el tamaño del panel, también supervisa las transacciones, igual que OnCalculate(), en el caso de que haya menos de 1 tick por segundo.  

void OnTimer()
  {
   int x_size=ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
   int y_size=ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
   //update the board if window size has changed
   if(x_size!=prev_x_size || y_size!=prev_y_size) tablo.Refresh();
   prev_x_size=x_size;
   prev_y_size=y_size;
   //update the board if number of deals has changed
   HistorySelect(0,TimeCurrent());
   int deals=HistoryDealsTotal();
   if(deals!=prev_deals) tablo.Refresh();
   prev_deals=deals;
  }

Compile y ejecute el indicador:

Figura 3. La vista final del panel

Figura 3. La vista final del panel

Conclusión

Querido lector, espero que haya encontrado algo nuevo en este artículo. He podido probar antes todas las posibilidades de un instrumento tan esplendido como es la Librería estándar, ya que proporciona comodidad, velocidad y un rendimiento de calidad superior. Por supuesto, debe tener algún conocimiento de POO (Programación orientada a objetos).

Buena suerte. 

Para empezar, descomprima el archivo MQL5.rar en la carpeta del terminal y de los permisos para utilizar los DLLs. El archivo DLL_Sources.zip contiene los códigos fuente de las librerías String_Metrics.dll y PNG_to_BMP.dll, las he escrito yo mismo en el entorno Borland C++ Builder con el GDI instalado.  

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/102

Archivos adjuntos |
dll_sources.zip (1.62 KB)
infoboard-doc-en.zip (1836.47 KB)
infoboard.zip (203.67 KB)
La Orden de Creación y Destrucción de Objetos en MQL5 La Orden de Creación y Destrucción de Objetos en MQL5

Cada objeto, ya sea un objeto personalizado, un array dinámico o un array de objetos, se crea y elimina en el programa MQL5 de una forma particular. A menudo, algunos objetos son parte de otros objetos, y el orden de eliminación de objetos durante la desinicialización se vuelve especialmente importante. Este artículo facilita algunos ejemplos que muestran los mecanismos para trabajar con objetos.

Limitaciones y verificaciones en Asesores Expertos Limitaciones y verificaciones en Asesores Expertos

¿Está permitido hacer operaciones de trading con este símbolo los lunes? ¿Hay suficiente dinero para abrir una posición? ¿Cuál sería el tamaño de la pérdida si se activa el Stop Loss? ¿Cómo se limita el número de órdenes pendientes? ¿Se ejecutó la operación de trading en la barra actual, o en la anterior? Si un robot de trading no puede ejecutar este tipo de verificaciones, cualquier estrategia de trading puede convertirse en una fuente de pérdidas. Este artículo muestra ejemplos de verificaciones que son útiles en cualquier Asesor Experto.

Funciones para la Gestión de fondos en un Expert Advisor Funciones para la Gestión de fondos en un Expert Advisor

El desarrollo de estrategias de trading se basa inicialmente en la búsqueda de pautas para entrar y salir del mercado, así como en el mantenimiento de las posiciones. Si somos capaces de poner algunas pautas en forma de reglas para el trading automatizado, entonces se encargará el trader del cálculo del volumen de las posiciones, el valor de los diferenciales, así como el mantenimiento de un nivel seguro de fondos hipotecarios para garantizar las posiciones abiertas en el modo automatizado. En este artículo usaremos el lenguaje MQL5 para realizar ejemplos sencillos sobre cómo llevar a cabo estos cálculos.

Cómo escribir un indicador basado en otro indicador Cómo escribir un indicador basado en otro indicador

En MQL5 puedes escribir un indicador desde cero o a partir de otro indicador que ya existe, integrado en el terminal o personalizado. Aquí también hay dos maneras -para mejorar el indicador añadiéndole cálculos y estilos gráficos, o utilizar un indicador integrado en el terminal de cliente o uno personalizado mediante las funciones iCustom() o IndicatorCreate()