Introducción

Al programar en el lenguaje MQL4, los principiantes a veces se encuentran con situaciones en las que los resultados de ciertos cálculos matemáticos se diferencian de los esperados. Así y con todo, el programa se compila y funciona, pero no de la forma necesaria. Entonces los principiantes empiezan a verificar el programa, encuentran nuevos "errores" en el lenguaje, en la implementación de las funciones, etc. En la mayoría de los casos, el análisis posterior muestra que todo va bien en el lenguaje y el compilador, mientras que el texto del código ocultaba un error enojoso cuya búsqueda puede llevar mucho tiempo.

En estos apuntes hemos reunido consejos para resolver los errores más frecuentes al trabajar con números del tipo double en los programas en MQL4.

1 Control de los valores numéricos

Para comprobar los resultados de los cálculos y la depuración de programas, se puede usar la función string DoubleToStrMorePrecision(double number, int precision); de la biblioteca estándar stdlib.mq4, que permite controlar los valores numéricos de los números del tipo double hasta el dígito indicado.

Esto permitirá ahorrar tiempo al buscar posibles errores.

Ejemplo de uso:

#include <stdlib.mqh>
int start()
  {
   double a=2.0/3;
   Alert("Standard output:",a,", 8 digits precision:",DoubleToStr(a,8),", 15 digits precision:", DoubleToStrMorePrecision(a,15));
   return(0);
  }  

Resultado:

Ejemplo del código:

#include <stdlib.mqh>
int start()
  {
   double a=2.0/100000;
   Alert("Standard output=",a,", More precise output=",DoubleToStrMorePrecision(a,15));
   return(0);
  }

como resultado, muestra: "Standard output=0, More precise output=0.000020000000000".

2. La precisión al trabajar con números del tipo double

Las especificidades del formato de guardado de números double en la computadora provocan la limitación de la precisión de su almacenamiento y la aparición de imprecisiones al trabajar con ellos.

Por ejemplo, al usar la precisión ilimitada de cálculo, para cualquier número A y B siempre serán válidas las expresiones:

(A/B)*(B)=A,

A-(A/B)*B=0,

(A/B)*(B/A)=1, etcétera.

En la computadora, la precisión de guardado de la cantidad de dígitos decimales de los números del tipo doube viene definida por el tamaño de la mantisa y está limitada a 52 bits.

Veamos el siguiente ejemplo, que ilustra la pérdida de precisión indicada. El programa mostrado más abajo calcula en el ciclo (i) el producto de los números enteros hasta 23 (23!=25852016738884976640000), el resultado de los cálculos se guarda en una variable (a) del tipo double. En el siguiente ciclo (j) se divide el número (a) por cada uno de los números enteros hasta 23. Como resultado, lo lógico sería esperar a=1.

#include <stdlib.mqh>
int start()
  {
   int maxfact=23;
   double a=1;
   for (int i=2; i<=maxfact; i++) { a=a*i; }
   for (int j=maxfact; j>=2; j--) { a=a/j; }
   Alert(" a=",DoubleToStrMorePrecision(a,16));
   return(0);
  }

Y sin embargo, tenemos:

De esta forma, al trabajar con números enteros, tenemos una imprecisión en el 16 dígito.

Si aumentamos el cálculo a 35!, obtendremos a=0.9999999999999998.

En el lenguaje MQL existe la función NormalizeDouble, que permite redondear un número del tipo double hasta la precisión indicada.

Sin embargo, no es conveniente confundir la precisión de representación de los números double, analizada más arriba, con los límites de sus cambios, que son bastante más amplios: de -1.7*e-308 a 1.7*e308.

Podemos valorar de forma aproximada el exponente mínimo del número double, que será indistinguible de 0, con la ayuda del código siguiente:

int start()
  {
  double R=1;
  int minpwr=0;
  while (R>0) {R=R/10; minpwr--;}
  Alert(minpwr);
  return(0);
  }

3. La función NormalizeDouble

La función double NormalizeDouble (double value, int digits) redondea el número value con una precisión de digits dígitos.

En el ejemplo:

int start()
  {
   double a=3.141592663589;
   Alert("a=",DoubleToStr(NormalizeDouble(a,5),8));
   return(0);
  }

el resultado será

4. Peculiaridades en la comparación de números del tipo double

Es recomendable realizar la operación de comparación de la igualdad de dos números double con la ayuda de la función bool CompareDoubles(double number1,double number2) de la biblioteca estándar stdlib.mq4, que tiene el aspecto:

//+------------------------------------------------------------------+
//| correct comparison of 2 doubles                                  |
//+------------------------------------------------------------------+
bool CompareDoubles(double number1,double number2)
  {
   if(NormalizeDouble(number1-number2,8)==0) return(true);
   else return(false);
  }

Esta función compara los números number1 y number2 del tipo double con una precisión de 8 dígitos decimales.

Ejemplo:

#include <stdlib.mqh>
int start()
  {double a=0.123456781;
   double b=0.123456782; 
   if (CompareDoubles(a,b)) {Alert("They are equal");}
   else {Alert("They are different");}
  }

mostrará

puesto que los números a y b se diferencian solo en el 9 dígito.

En caso necesario, el uso de una precisión más elevada se puede escribir de forma análoga en su propia función de comparación hasta la precisión necesaria.

5. División de números enteros

Debemos recordar que al dividir dos números enteros, el resultado será un número entero.

Por eso el código:

int start()
  {
   Alert(70/100);
   return(0);
  }

mostrará 0, puesto que 70 y 100 son valores enteros. Al igual que en el lenguaje C, en MQL4 el resultado de la división de un número entero por otro no será un número entero, en este caso, será 0.

Sin embargo, si uno de sus valores es un número del tipo double (es decir, tiene una parte fraccionada), el resultado de la división será un número del tipo double. Por eso, Alert(70/100.0); dará el número 0.7. Asimismo, debemos recordar las normas de conversión de tipos y formalizar con más cuidado la expresión.

Ejemplo del código:

int start()
  { double a=1/3;
    double b=1.0/3;
   Alert("a=",a,", b=",b);
   return(0);
  }

dará a=0, b=0.3333

6. Conversión de tipos para integer y double

Vamos a ver este segmento de código:

double xbaseBid=1.2972;
double xBid=1.2973;
double xPoint=0.0001;
int i = 100 + (xBid - xbaseBid)/xPoint;
Alert(i);

Como resultado del trabajo, se mostrará el número 100, aunque parece que (i) debería ser igual a 101, dado que 0.0001/0.0001=1.

Un ejemplo análogo en C/C++:

double baseBid=1.2972,Bid=1.2973,Point=0.0001;
int i = 100 + (Bid - baseBid)/Point;
printf("%d\n",i);

también dara 100.

Para investigar los motivos de esta circunstancia, analizaremos el código:

double a=0.99999999999999;
int i = 100 + a;
Alert(i);

El resultado del funcionamiento será la muestra del número i=100.

Sin embargo, si mejoramos la precisión de la cifra a:

double a=0.999999999999999;
int i = 100 + a;
Alert(i);

obtendremos 101. La causa es el uso mezclado de números enteros y números con punto flotante, el motivo empeora por la reducida precisión de los valores.

Por eso, al realizar operaciones de este tipo, se recomienda redondear estas expresiones con la ayuda de la función double MathRound(double value), que retorna un valor redondeado hasta el número entero más próximo al valor numérico indicado:

double baseBid=1.2972;
double xBid=1.2973;
double xPoint=0.0001;
int i = 100 + MathRound((xBid - baseBid)/xPoint);
Alert(i);

En este caso, obtendremos el valor correcto 101.

7. Peculiaridades de la función MathMod

El resultado del funcionamiento de la función MathMod(double v1, double v2) en el lenguaje MQL4 se corresponde totalmente con el resultado del funcionamiento de la función fmod(double v1, double v2) de la biblioteca matemática MSVC6, puesto que al ser ejecutada se usa la llamada directa de esta función en C Runtime Library. En algunos casos, la función fmod en MSVC6 (y por consiguiente MathMod), da un resultado incorrecto.

Si en sus programas se usa esta función, sustituya la llamada de MathMod por la llamada de la siguiente función, que siempre retorna el resultado correcto:

double MathModCorrect(double a, double b)
{ int tmpres=a/b;
return(a-tmpres*b);
}