<QtNumeric> - Qt Numeric Functions

Documentación de funciones

[constexpr] template <typename T> T qAbs(const T &t)

Compara t con el 0 del tipo T y devuelve el valor absoluto. Así, si T es doble, entonces t se compara con (doble) 0.

Ejemplo:

int absoluteValue;
int myValue = -4;

absoluteValue = qAbs(myValue);
// absoluteValue == 4

[constexpr, since 6.1] template <typename T> typename std::enable_if_t<std::is_unsigned_v<T>, bool> qAddOverflow(T v1, T v2, T *result)

Suma dos valores v1 y v2, de tipo numérico T y registra el valor en result. Si la suma desborda el rango válido para el tipo T, devuelve true, en caso contrario devuelve false.

Se garantiza la disponibilidad de una implementación para tipos enteros de 8, 16 y 32 bits, así como para tipos enteros del tamaño de un puntero. La matemática de desbordamiento para otros tipos, si está disponible, se considera API privada.

Esta función se introdujo en Qt 6.1.

quint64 qFloatDistance(double a, double b)

Devuelve el número de números de coma flotante representables entre a y b.

Esta función tiene el mismo propósito que qFloatDistance(float, float), pero devuelve la distancia entre dos números double. Dado que el rango es mayor que para dos números float ([-DBL_MAX,DBL_MAX]), el tipo de retorno es quint64.

Véase también qFuzzyCompare().

quint32 qFloatDistance(float a, float b)

Devuelve el número de números de coma flotante representables entre a y b.

Esta función proporciona una forma alternativa de realizar comparaciones aproximadas de números de coma flotante similar a qFuzzyCompare(). Sin embargo, devuelve la distancia entre dos números, lo que da al que llama la posibilidad de elegir el error aceptado. Los errores son relativos, así por ejemplo la distancia entre 1.0E-5 y 1.00001E-5 dará 110, mientras que la distancia entre 1.0E36 y 1.00001E36 dará 127.

Esta función es útil si una comparación en coma flotante requiere una cierta precisión. Por lo tanto, si a y b son iguales devolverá 0. El valor máximo que devolverá para números de coma flotante de 32 bits es 4.278.190.078. Esta es la distancia entre -FLT_MAX y +FLT_MAX.

La función no da resultados significativos si alguno de los argumentos es Infinite o NaN. Puede comprobarlo llamando a qIsFinite().

El valor de retorno puede considerarse como el "error", así que si por ejemplo quieres comparar dos números en coma flotante de 32 bits y todo lo que necesitas es una precisión aproximada de 24 bits, puedes usar esta función así:

    if (qFloatDistance(a, b) < (1 << 7)) {   // The last 7 bits are not
                                            // significant
        // precise enough
    }

Véase también qFuzzyCompare().

Clasifica un valor de coma flotante.

Los valores de retorno se definen en <cmath>: devuelve uno de los siguientes, determinado por la clase de punto flotante de val:

• FP_NAN no es un número
• FP_INFINITE infinitos (positivos o negativos)
• FP_ZERO cero (positivo o negativo)
• FP_NORMAL finito con mantisa completa
• FP_SUBNORMAL finito con mantisa reducida

[constexpr noexcept] bool qFuzzyCompare(double p1, double p2)

Compara el valor de coma flotante p1 y p2 y devuelve true si se consideran iguales, en caso contrario false.

Tenga en cuenta que no funcionará la comparación de valores en los que p1 o p2 sea 0,0, ni la comparación de valores en los que uno de los valores sea NaN o infinito. Si uno de los valores es siempre 0.0, utilice qFuzzyIsNull en su lugar. Si es probable que uno de los valores sea 0,0, una solución es sumar 1,0 a ambos valores.

// Instead of comparing with 0.0
qFuzzyCompare(0.0, 1.0e-200); // This will return false
// Compare adding 1 to both values will fix the problem
qFuzzyCompare(1 + 0.0, 1 + 1.0e-200); // This will return true

Los dos números se comparan de forma relativa, donde la exactitud es mayor cuanto más pequeños son los números.

Nota: Esta función es thread-safe.

[constexpr noexcept] bool qFuzzyCompare(float p1, float p2)

Compara el valor en coma flotante p1 y p2 y devuelve true si se consideran iguales, en caso contrario false.

Los dos números se comparan de forma relativa, donde la exactitud es mayor cuanto más pequeños son los números.

Nota: Esta función es thread-safe.

[constexpr noexcept] bool qFuzzyIsNull(double d)

Devuelve verdadero si el valor absoluto de d está dentro de 0.000000000001 de 0.0.

Nota: Esta función es segura para hilos.

[constexpr noexcept] bool qFuzzyIsNull(float f)

Devuelve verdadero si el valor absoluto de f está dentro de 0.00001f de 0.0.

Nota: Esta función es segura para hilos.

double qInf()

Devuelve el patrón de bits de un número infinito como un doble.

Véase también qIsInf().

bool qIsFinite(double d)

Devuelve true si el doble d es un número finito.

bool qIsFinite(float f)

Devuelve true si el flotador f es un número finito.

bool qIsInf(double d)

Devuelve true si el doble d es equivalente a infinito.

Véase también qInf().

bool qIsInf(float f)

Devuelve true si el float f es equivalente a infinito.

Véase también qInf().

bool qIsNaN(double d)

Devuelve true si el doble d no es un número (NaN).

bool qIsNaN(float f)

Devuelve true si el flotador f no es un número (NaN).

[constexpr, since 6.1] template <typename T> typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qMulOverflow(T v1, T v2, T *result)

Multiplica v1 y v2, y registra el valor resultante en result. Si la multiplicación desborda el rango válido para el tipo T, devuelve true, en caso contrario devuelve false.

Se garantiza la disponibilidad de una implementación para tipos enteros de 8, 16 y 32 bits, así como para tipos enteros del tamaño de un puntero. La matemática de desbordamiento para otros tipos, si está disponible, se considera API privada.

Esta función se introdujo en Qt 6.1.

double qQNaN()

Devuelve el patrón de bits de un NaN silencioso como un double.

Véase también qIsNaN().

[constexpr] qint64 qRound64(double d)

Redondea d al entero de 64 bits más cercano.

Redondea a la mitad de cero (por ejemplo, 0,5 -> 1, -0,5 -> -1).

Ejemplo:

double valueA = 42949672960.3;
double valueB = 42949672960.7;

qint64 roundedValueA = qRound64(valueA);
// roundedValueA = 42949672960
qint64 roundedValueB = qRound64(valueB);
// roundedValueB = 42949672961

[constexpr] qint64 qRound64(float d)

Redondea d al entero de 64 bits más cercano.

Redondea a la mitad de cero (por ejemplo, 0.5f -> 1, -0.5f -> -1).

Ejemplo:

float valueA = 42949672960.3f;
float valueB = 42949672960.7f;

qint64 roundedValueA = qRound64(valueA);
// roundedValueA = 42949672960
qint64 roundedValueB = qRound64(valueB);
// roundedValueB = 42949672961

[constexpr] int qRound(double d)

Redondea d al entero más cercano.

Redondea a la mitad de cero (por ejemplo, 0,5 -> 1, -0,5 -> -1).

Ejemplo:

double valueA = 2.3;
double valueB = 2.7;

int roundedValueA = qRound(valueA);
// roundedValueA = 2
int roundedValueB = qRound(valueB);
// roundedValueB = 3

[constexpr] int qRound(float d)

Redondea d al entero más cercano.

Redondea a la mitad de cero (por ejemplo, 0.5f -> 1, -0.5f -> -1).

Ejemplo:

float valueA = 2.3f;
float valueB = 2.7f;

int roundedValueA = qRound(valueA);
// roundedValueA = 2
int roundedValueB = qRound(valueB);
// roundedValueB = 3

double qSNaN()

Devuelve el patrón de bits de un NaN de señalización como un doble.

[constexpr, since 6.1] template <typename T> typename std::enable_if_t<std::is_unsigned_v<T>, bool> qSubOverflow(T v1, T v2, T *result)

Resta v2 de v1 y registra el valor resultante en result. Si la resta desborda el rango válido para el tipo T, devuelve true, en caso contrario devuelve false.

Se garantiza la disponibilidad de una implementación para tipos enteros de 8, 16 y 32 bits, así como para tipos enteros del tamaño de un puntero. La matemática de desbordamiento para otros tipos, si está disponible, se considera API privada.

Esta función se introdujo en Qt 6.1.