Bibliotecas: Math Utils - página 4

Novo comentário
 

fxsaber #:

Você precisa aprender a fazer medições de desempenho adequadas.

Você está tirando conclusões erradas.

Infelizmente, você não entende o que está medindo.

Portanto, diga-me o que não estou entendendo, por favor :-)

 
Até agora, entendo que devo substituir o código pela sua função otimizada (!) e, em seguida, colocar um grande aviso para que os usuários desabilitem as otimizações do compilador antes de usar a biblioteca, a fim de obter o mesmo desempenho que obteriam sem usar toda essa porcaria!
 
amrali #:
Até agora, entendo que devo substituir o código pela sua função otimizada (!) e, em seguida, colocar um grande aviso para que os usuários desativem as otimizações do compilador antes de usar a biblioteca, a fim de obter o mesmo desempenho que obteriam sem usar toda essa porcaria!

Se, de fato, você deseja descobrir como medir corretamente o desempenho de qualquer função, vá ao fórum em russo e pergunte lá. Os desenvolvedores falaram sobre isso em detalhes com exemplos. Não tenho nenhum link.

 
Agradecimentos
 

Atualização 1 de março de 2023

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

//+------------------------------------------------------------------+
//| Obter o número de dígitos fracionários que concordam após o decimal
//| Ponto de dois números. GetEqualDigits(3.124, 3.122) => 2 |
//+------------------------------------------------------------------+
int GetEqualDigits(const double a, const double b);

//+------------------------------------------------------------------+
//| Obter o número de dígitos significativos que concordam entre dois números.
//| Por exemplo, GetEqualSignificantDigits(3.124, 3.122) => 3 |
//+------------------------------------------------------------------+
int GetEqualSignificantDigits(const double a, const double b);

Adicionadas funções diversas:

//+------------------------------------------------------------------+
//| Obter o número de dígitos significativos. Dígitos ou números significativos
//| é a soma dos dígitos inteiros e decimais (à esquerda e à direita do símbolo |
//| ponto decimal), excluindo os zeros à esquerda e à direita.
//| Por exemplo, o número 1,23 tem 2 casas decimais e 3 s.f.
//| Dica: mude o número para notação científica. É mais fácil de ver. |
//+------------------------------------------------------------------+
int GetSignificantDigits(double value);

//+------------------------------------------------------------------+
//| Retorna o expoente da notação científica de um número.
//| Na notação científica, um número é convertido em um número decimal.
//| entre 1,0 e 10, multiplicado por 10 elevado a alguma potência.
//| Calcula o deslocamento do ponto decimal para manter apenas um ponto diferente de zero.
//| dígito antes do ponto decimal.|
//+------------------------------------------------------------------+
int GetExponent10(const double value)l

//+------------------------------------------------------------------+
//| Calcula o sinal de um valor como 1, 0, -1
//+------------------------------------------------------------------+
double MathSign(const double value);

Adicionada função para formatação de duplas em string:

//+------------------------------------------------------------------+
//| Conversão de valor numérico em uma cadeia de caracteres em notação científica
//| com um dígito antes do ponto decimal (por exemplo, 6.22e-23).
//| Dígitos : Opcional. O número de dígitos após o ponto decimal. |
//| O padrão é ter tantos dígitos quantos forem necessários para representar o valor.
//+------------------------------------------------------------------+
string DoubleToExponential(const double value, int digits = -1);


 
Atualização 8 de março de 2023

Adicionada nova função diversa.

//+------------------------------------------------------------------+
//| Retorna pow(10, (int)power), usa uma tabela de pesquisa rápida para potências.
//| https://github.com/php/php-src/blob/master/ext/standard/math     |
//+------------------------------------------------------------------+
double GetPower10(const int power);

A função tem um desempenho muito mais rápido do que MathPow(10, power).

 
fxsaber #:

Mais rápido.

@fxsaber Obrigado!

Fórum sobre negociação, sistemas de negociação automatizados e teste de estratégias de negociação

Bibliotecas: Math Utils

amrali, 2023.03.08 15:32

Atualização 8 de março de 2023

Adicionada nova função diversa.

//+------------------------------------------------------------------+
//| Retorna pow(10, (int)power), usa uma tabela de pesquisa rápida para potências.
//+------------------------------------------------------------------+
double GetPower10(const int power);

A função tem um desempenho muito mais rápido do que MathPow(10, power).


 

Foram adicionadas funções de arredondamento mais rápidas.

//+------------------------------------------------------------------+
//| Ceil, floor e round rápidos usando operadores aritméticos.
//+------------------------------------------------------------------+
inline long Ceil (const double v);
inline long Floor(const double v);
inline long Round(const double v);
inline long Trunc(const double v);
A vantagem de velocidade em relação ao MathCeil, MathFloor e MathRound incorporados é de cerca de 160-240%.


 

Atualização 24 de abril de 2023

Adicionada nova função:

//+------------------------------------------------------------------+
//| Envolva um valor entre o mínimo (inclusive) e o máximo (exclusivo).
//+------------------------------------------------------------------+
template<typename T>
T Wrap(const T value, const T min, const T max);

Renomeou as funções de arredondamento para Ceil(), Floor(), Round() e Trunc() para evitar conflitos de nomes com <Math\Stat\Math.mqh>.

Corrigida a função GetDigits() para evitar um loop infinito em situações raras.

 
Essas são três funções úteis para comparação e arredondamento de números de ponto flutuante e formatação de dinheiro:

1. `bool DoubleEquals(double x, double y, double eps)` compara dois valores duplos `x` e `y` com um determinado valor de epsilon `eps` e retorna um valor booleano indicando se eles são iguais dentro da tolerância determinada.

2. `double RoundTo(double value, int digits)` arredonda um valor duplo `value` para o número de dígitos decimais fornecido.

3. `string FormatMoney(double amount)` formata um valor duplo `amount` como uma string que representa um valor monetário. Ele formata o valor com duas casas decimais, substitui o ponto decimal por uma vírgula e insere espaços a cada três dígitos para facilitar a leitura. Ele também adiciona o símbolo de moeda obtido de `AccountInfoString(ACCOUNT_CURRENCY)` no final.

  1. DoubleEquals(double x, double y, double eps) - Essa função compara dois valores duplos x e y com uma tolerância eps . Ela retorna verdadeiro se x estiver dentro de eps de y . Isso é útil para comparar números de ponto flutuante que podem não ser exatamente iguais devido a erros de arredondamento.

bool DoubleEquals(double x, double y, double eps) { return fabs(x - y) < eps; }

  1. RoundTo(double value, int digits) - Essa função arredonda um valor duplo para um número especificado de dígitos decimais. Ela usa a função MathRound() para realizar o arredondamento.

double RoundTo(double value, int digits) { double factor = pow(10, digits); return MathRound(value * factor) / factor; }

  1. FormatMoney(double amount) - Essa função formata um valor duplo como uma cadeia de caracteres com símbolos de moeda, vírgulas para separadores de milhares e duas casas decimais. É útil para exibir valores monetários de forma amigável para o usuário.
string FormatMoney(double amount) {
    string currency = AccountInfoString(ACCOUNT_CURRENCY);
    string formatted = StringFormat("%.2f", amount);
    formatted = StringReplace(formatted, ".", ",");
    int len = StringLen(formatted);
    for (int i = len - 6; i > 0; i -= 3) {
       formatted = StringSubstr(formatted, 0, i) + " " + StringSubstr(formatted, i);
    }
    return formatted + " " + currency;
}

Postagem formatada pelo moderador

123456
Novo comentário