Librerías: Math Utils - página 4

Nuevo comentario
 

fxsaber #:

Tienes que aprender a hacer mediciones de rendimiento adecuadas.

Está sacando conclusiones erróneas.

Por desgracia, no entiende lo que está midiendo.

Dígame qué es lo que no entiendo, por favor :-)

 
¡Hasta ahora, entiendo que debería reemplazar el código con tu función optimizada (!), y luego poner una gran advertencia para que los usuarios desactiven las optimizaciones del compilador antes de usar la biblioteca, ¡para obtener el mismo rendimiento que obtendrían sin usar toda esta mierda!
 
amrali #:
¡Hasta ahora, entiendo que debería reemplazar el código con tu función optimizada (!), y luego poner una gran advertencia para que los usuarios desactiven las optimizaciones del compilador antes de usar la librería, ¡para obtener el mismo rendimiento que obtendrían sin usar toda esta mierda!

Si, de hecho, tienes ganas de averiguar cómo medir correctamente el rendimiento de cualquier función, ve al foro en ruso y pregunta allí. Los desarrolladores hablaron de ello en detalle con ejemplos. No tengo enlaces.

 
Gracias
 

Actualización 1 de marzo de 2023

Añadidas funciones para comparación de dobles:

//+------------------------------------------------------------------+
//| Obtener el número de dígitos fraccionarios que coinciden después del decimal |
//| punto de dos números. GetEqualDigits(3.124, 3.122) => 2 ||
//+------------------------------------------------------------------+
int GetEqualDigits(const double a, const double b);

//+------------------------------------------------------------------+
//| Obtener el número de dígitos significativos que coinciden de dos números. ||
//| Por ejemplo, GetEqualSignificantDigits(3.124, 3.122) => 3 ||
//+------------------------------------------------------------------+
int GetEqualSignificantDigits(const double a, const double b);

Añadidas funciones varias:

//+------------------------------------------------------------------+
//| Obtener el número de dígitos significativos. Cifras o dígitos significativos |
//| es la suma de los dígitos enteros y decimales (a la izquierda y a la derecha del |
//| (punto decimal), excluyendo los ceros a la izquierda y a la derecha.
//| Por ejemplo, el número 1,23 tiene 2 decimales y 3 s.f.
//| Sugerencia: Cambia el número a notación científica. Es más fácil de ver. |
//+------------------------------------------------------------------+
int GetSignificantDigits(double value);

//+------------------------------------------------------------------+
//| Devuelve el exponente de la notación científica de un número. ||
//| En notación científica un número se convierte a un número decimal ||
//| entre 1.0 y 10, multiplicado por 10 elevado a alguna potencia. ||
//| Calcula desplazar el punto decimal para mantener sólo un no-cero |
//| dígito antes del punto decimal.|
//+------------------------------------------------------------------+
int GetExponent10(const double value)l

//+------------------------------------------------------------------+
//| Calcula el signo de un valor como 1, 0, -1 |
//+------------------------------------------------------------------+
double MathSign(const double value);

Añadida función para formatear dobles a cadena:

//+------------------------------------------------------------------+
//| Conversión de un valor numérico en una cadena en notación científica ||
//| con un dígito antes del punto decimal (por ejemplo, 6.22e-23).
//| Dígitos : Opcional. El número de dígitos después del punto decimal. |
//| Por defecto tantos dígitos como sean necesarios para representar el valor. ||
//+------------------------------------------------------------------+
string DoubleToExponential(const double value, int digits = -1);


 
Actualización 8 de marzo de 2023

Añadida nueva función miscelánea.

//+------------------------------------------------------------------+
//| Devuelve pow(10, (int)power), usa tabla de búsqueda rápida para potencias. ||
//| https://github.com/php/php-src/blob/master/ext/standard/math     |
//+------------------------------------------------------------------+
double GetPower10(const int power);

La función tiene un rendimiento mucho más rápido que MathPow(10, power).

 
fxsaber #:

Más rápido.

@fxsaber ¡Gracias!

Foro sobre trading, sistemas automatizados de trading y testeo de estrategias de trading

Bibliotecas: Math Utils

amrali, 2023.03.08 15:32

Actualización 8 marzo 2023

Añadida nueva función miscelánea.

//+------------------------------------------------------------------+
//| Devuelve pow(10, (int)power), usa tabla de búsqueda rápida para potencias. ||
//+------------------------------------------------------------------+
double GetPower10(const int power);

La función tiene un rendimiento mucho más rápido que MathPow(10, power).


 

Añadidas funciones de redondeo más rápidas.

//+------------------------------------------------------------------+
//| Máximo, mínimo y redondeo rápidos mediante 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);
la ventaja de velocidad sobre MathCeil, MathFloor y MathRound incorporados es de aproximadamente 160-240%.


 

Actualización 24 abril 2023

Añadida nueva función:

//+------------------------------------------------------------------+
//| Envuelve un valor entre min (inclusive) y max (exclusive). ||
//+------------------------------------------------------------------+
template<typename T>
T Wrap(const T value, const T min, const T max);

Renombradas las funciones de redondeo a Ceil(), Floor(), Round() y Trunc() para evitar conflictos de nombres con <Math\Stat\Math.mqh>.

Corregida la función GetDigits() para evitar un bucle infinito en raras situaciones.

 
Estas son tres prácticas funciones para comparar y redondear números en coma flotante y formatear dinero:

1. `bool DoubleEquals(double x, double y, double eps)` compara dos valores dobles `x` e `y` con un valor épsilon dado `eps` y devuelve un valor booleano indicando si son iguales dentro de la tolerancia dada.

2. `double RoundTo(double value, int digits)` redondea un valor doble `value` al número dado de `digits` decimales.

3. 3. `string FormatMoney(double amount)` formatea un valor doble `amount` como una cadena que representa un importe monetario. Formatea el importe con dos decimales, sustituye el punto decimal por una coma e inserta espacios cada tres dígitos para facilitar la lectura. También añade el símbolo de moneda obtenido de `AccountInfoString(ACCOUNT_CURRENCY)` al final.

  1. DoubleEquals(double x, double y, double eps) - Esta función compara dos valores dobles x e y con una tolerancia eps . Devuelve verdadero si x está dentro de eps de y . Resulta útil para comparar números en coma flotante que pueden no ser exactamente iguales debido a errores de redondeo.

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

  1. Redondear(valor doble, dígitos int) - Esta función redondea un valor doble a un número especificado de dígitos decimales. Utiliza la función MathRound() para realizar el redondeo.

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

  1. FormatMoney(double amount) - Esta función formatea un importe de valor doble como una cadena con símbolos de moneda, comas para separadores de miles y dos decimales. Es útil para mostrar valores monetarios de una manera fácil de usar.
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;
}

Mensaje formateado por el moderador

123456
Nuevo comentario