Librerías: Math Utils

Nuevo comentario
 

Math Utils:

Funciones cómodas para comparar y redondear los números con punto flotante (en precios, lotes, dinero).

Autor: amrali

 

Actualización 19 mayo 2021

Añadidas funciones de depuración

// Convertir el valor numérico en la cadena de texto decimal exacta.
string DoubleToStringExact(double value);

// Convertir el valor numérico en la cadena de texto hexadecimal en bruto.
string DoubleToHexadecimal(double value);
 
Actualización 21 mayo 2021

Añadidas varias funciones

// Convierte x en el rango [min, max] a y en otro rango [new_min, new_max]. 
// Se puede utilizar para reescalar valores de indicadores u objetos gráficos.
double map_range(double x, double min, double max, double new_min, double new_max);

// Obtener el número de dígitos después del punto decimal.
int GetDigits(double number);
 

Actualización 27 mayo 2021

Añadidas funciones para depuración

// Devuelve int diferencia entre dos flotantes expresado en epsilon (ulps).
long UlpDiff(const double num1, const double num2);

// Devuelve el siguiente valor representable después de x
double nextafter(double num);

Añadidas funciones varias

bool IsRound(const double number, const int digits);

bool IsRoundToStep(const double number, const double step);
Añadido script'dotnet_cross_check.mq5' y 'RoundSharp.dll' escrito en C#.

 
Actualización 30 de mayo de 2021

Añadidas funciones varias

//Obtener el número de dígitos enteros a la izquierda del punto decimal.
int    IntegerDigits(double number);

//mapa x en una escala [min, max] a escala normalizada [0, 1].
double normalize(double x, double min, double max);

Funciones útiles para la representación binaria de dobles

//Devuelve el valor doble correspondiente a una representación de bits.
double LongBitsToDouble(long bits);

//Devuelve la representación en bits correspondiente a un valor doble .
long   DoubleToLongBits(double value);

//Devuelve el exponente no sesgado utilizado en la representación de bits.
int    GetExponent(double value);

//Devuelve la mantisa utilizada en la representación de bits.
long   GetMantissa(double value);

//Devuelve el tamaño de un ulp del argumento.
double Ulp(double value);

Funciones prácticas para la representación de cadenas de dobles

// Conversión del valor numérico en la representación de cadena más corta
// que redondea al mismo valor numérico.
string Repr(double value);
 

Actualización 1 de junio de 2021

Añadidas nuevas funciones:

// Devuelve la codificación bruta del exponente en la representación de bits.
int    RawExponent(double value);

// Devuelve la codificación en bruto del significando en la representación de bits.
long   RawSignificand(double value);

// Devuelve el exponente insesgado (ajustado) de un valor doble.
int    Exponent(double value);

// Devuelve el significando de un valor doble.
double Significand(double value);

// Determinar si el número es representable exactamente en double.
bool   IsExactDouble(double value);

// Formatea el número con el separador de miles.
string FormatNumber(const double number,const string separator=",");
 
Actualización 17 de junio de 2021

Añadidas nuevas funciones: 
// Determina si el valor pasado es un entero.
bool   IsInteger(double num);

// Obtener parte decimal (siempre positiva)
double GetFraction(double num);

// Recortar (limitar) un número a unos límites (rango)
template<typename T>
T      Clip(T value, T low, T high);

// En mql, el error de división por cero obliga al programa mql a detenerse.
double safeDiv(double x, double y);

// Convertir el valor numérico en la cadena hexadecimal de la constante float.
string DoubleToHexFloatConstant(double value);
 

Actualización 20 junio 2021

Añadida nueva función:

// Avanza un número de coma flotante un número especificado de ULPs.
double DoubleAdvance(double value, long distance);


 

Actualización 21 junio 2021

Añadida nueva macro de tipo función:

// Imprime dobles utilizando el especificador de formato de ida y vuelta ("%.17g").
#define  PRINT_R(A) Print(#A + " = ", Repr(A))


 
¿se pueden añadir a mt4? ¿los has probado en mt4? (me refiero al archivo de inclusión)
 

Actualización 27 de enero de 2023

Renombradas las funciones de redondeo para ser más consistentes:

double MathRound(const double value, const int digits);

double MathRound(const double value, const double step);

double MathFloor(const double value, const int digits);

double MathFloor(const double value, const double step);

double MathCeil(const double value, const int digits);

double MathCeil(const double value, const double step);

double MathTrunc(const double value, const int digits);

double MathTrunc(const double value, const double step);

Añadidas dos nuevas funciones para comparar dobles:

//+------------------------------------------------------------------+
//| Comprobar casi igualdad (ignorar pequeño error de rounoff) ||
//| Si las representaciones binarias de dos dobles difieren en más de |
//| un bit menos significativo (ulp), la función devuelve false. ||
//+------------------------------------------------------------------+
bool AlmostEqual(const double a, const double b);

//+------------------------------------------------------------------+
//| Comprueba si dos números de coma flotante están cerca en valor. ||
//| Donde, n: es el número de dígitos significativos que hemos perdido ||
//| a través de errores de redondeo (Máxima diferencia de precisión permitida). ||
//| Algo como n = 2 o 3 suele funcionar en la práctica. ||
//+------------------------------------------------------------------+
bool IsClose(const double a, const double b, const int maxDifferentSignificantDigits = 2);
123456
Nuevo comentario