Bibliotecas: Math Utils

Novo comentário
 

Math Utils:

Funções úteis para comparação e arredondamento de números de ponto flutuante (preços, lotes e dinheiro).

Autor: amrali

 

Atualização 19 de maio de 2021

Funções adicionadas para depuração

// Conversão do valor numérico em uma cadeia de texto decimal exata.
string DoubleToStringExact(double value);

// Conversão do valor numérico em uma cadeia de texto hexadecimal bruta.
string DoubleToHexadecimal(double value);
 
Atualização 21 de maio de 2021

Adicionadas funções diversas

// Converter x no intervalo [min, max] para y em outro intervalo [new_min, new_max]. 
// Isso pode ser usado para redimensionar valores de indicadores ou objetos gráficos.
double map_range(double x, double min, double max, double new_min, double new_max);

// Obter o número de dígitos após o ponto decimal.
int GetDigits(double number);
 

Atualização 27 de maio de 2021

Adicionadas funções para depuração

// Retorna a diferença int entre dois floats expressa em epsilon (ulps).
long UlpDiff(const double num1, const double num2);

// Retorna o próximo valor representável após x
double nextafter(double num);

Adicionadas funções diversas

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

bool IsRoundToStep(const double number, const double step);
Adicionados o script'dotnet_cross_check.mq5' e 'RoundSharp.dll' escritos em C#.

 
Atualização 30 de maio de 2021

Funções diversas adicionadas

/Obter o número de dígitos inteiros à esquerda do ponto decimal.
int    IntegerDigits(double number);

//mapear x em uma escala [min, max] para a escala normalizada [0, 1].
double normalize(double x, double min, double max);

Funções úteis para a representação binária de duplas

//Retorna o valor duplo correspondente a uma representação de bits.
double LongBitsToDouble(long bits);

//Retorna a representação de bits correspondente a um valor duplo.
long   DoubleToLongBits(double value);

//Retorna o expoente imparcial usado na representação de bits.
int    GetExponent(double value);

//Retorna a mantissa usada na representação de bits.
long   GetMantissa(double value);

//Retorna o tamanho de um ulp do argumento.
double Ulp(double value);

Funções úteis para a representação de strings de duplas

// Conversão do valor numérico na representação de string mais curta
// que se transforma no mesmo valor numérico.
string Repr(double value);
 

Atualização 1 de junho de 2021

Adicionadas novas funções:

// Retorna a codificação bruta do expoente na representação de bits.
int    RawExponent(double value);

// Retorna a codificação bruta do significante na representação de bits.
long   RawSignificand(double value);

// Retorna o expoente não tendencioso (ajustado) de um valor duplo.
int    Exponent(double value);

// Retorna o significante de um valor duplo.
double Significand(double value);

// Determinar se o número é exatamente representável em double.
bool   IsExactDouble(double value);

// Formata o número com separador de milhares.
string FormatNumber(const double number,const string separator=",");
 
Atualização 17 de junho de 2021

Adicionadas novas funções: 
// Determina se o valor passado é um número inteiro.
bool   IsInteger(double num);

// Obter a parte decimal (sempre positiva)
double GetFraction(double num);

// Recortar (limitar) um número aos limites (intervalo)
template<typename T>
T      Clip(T value, T low, T high);

// No mql, o erro de divisão zero força o programa mql a parar.
double safeDiv(double x, double y);

// Conversão do valor numérico em uma string de constante de flutuação hexadecimal.
string DoubleToHexFloatConstant(double value);
 

Atualização 20 de junho de 2021

Adicionada nova função:

// Avança um número de ponto flutuante em um número especificado de ULPs.
double DoubleAdvance(double value, long distance);


 

Atualização 21 de junho de 2021

Adicionada nova macro semelhante a uma função:

// Imprimir duplas usando o especificador de formato round-trip ("%.17g").
#define  PRINT_R(A) Print(#A + " = ", Repr(A))


 
Você já testou esses recursos no mt4? (o arquivo de inclusão, quero dizer)
 

Atualização de 27 de janeiro de 2023

Renomeação das funções de arredondamento para torná-las mais 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);

Adicionadas duas novas funções para comparação de duplas:

//+------------------------------------------------------------------+
//| Verificar quase a igualdade (ignorar o pequeno erro de desvio)
//| Se as representações binárias de duas duplas diferirem em mais de
//| um bit menos significativo (ulp), a função retorna falso.
//+------------------------------------------------------------------+
bool AlmostEqual(const double a, const double b);

//+------------------------------------------------------------------+
//| Verificar se dois números de ponto flutuante estão próximos em valor.
//| Onde, n: é o número de dígitos significativos que perdemos
//| por meio de erros de arredondamento (diferença de precisão máxima permitida).
//| Algo como n = 2 ou 3 geralmente funciona na prática.
//+------------------------------------------------------------------+
bool IsClose(const double a, const double b, const int maxDifferentSignificantDigits = 2);
123456
Novo comentário