<QtNumeric> - Qt Numeric Functions

El archivo de cabecera <QtNumeric> proporciona funciones numéricas comunes. Más información...

Header: #include <QtNumeric>

Funciones

T qAbs(const T &t)
(since 6.1) typename std::enable_if_t<std::is_unsigned_v<T>, bool> qAddOverflow(T v1, T v2, T *result)
quint64 qFloatDistance(double a, double b)
quint32 qFloatDistance(float a, float b)
int qFpClassify(double val)
int qFpClassify(float val)
bool qFuzzyCompare(double p1, double p2)
bool qFuzzyCompare(float p1, float p2)
bool qFuzzyIsNull(double d)
bool qFuzzyIsNull(float f)
double qInf()
bool qIsFinite(double d)
bool qIsFinite(float f)
bool qIsInf(double d)
bool qIsInf(float f)
bool qIsNaN(double d)
bool qIsNaN(float f)
(since 6.1) typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qMulOverflow(T v1, T v2, T *result)
double qQNaN()
qint64 qRound64(double d)
qint64 qRound64(float d)
int qRound(double d)
int qRound(float d)
double qSNaN()
(since 6.1) typename std::enable_if_t<std::is_unsigned_v<T>, bool> qSubOverflow(T v1, T v2, T *result)

Descripción detallada

El archivo de cabecera <QtNumeric> contiene diversas funciones numéricas para comparar y ajustar un valor numérico.

Documentación de las funciones

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

Compara t con el 0 del tipo T y devuelve el valor absoluto. Por lo tanto, si T es de tipo double, entonces t se compara con el 0 (de tipo double).

Ejemplo:

int absoluteValue;
int myValue = -4;

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

Nota: Si T es un tipo entero con signo y t tiene el valor std::numeric_limits<T>::min(), el comportamiento es indefinido.

[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 almacena el resultado en result. Si la suma desborda el rango válido del tipo T, devuelve true; en caso contrario, devuelve false.

Se garantiza la disponibilidad de una implementación para los tipos de enteros de 8, 16 y 32 bits, así como para los tipos de enteros del tamaño de un puntero. Las operaciones matemáticas de desbordamiento para otros tipos, si están disponibles, se consideran 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 la misma finalidad que qFloatDistance(float, float), pero devuelve la distancia entre dos números double. Dado que el rango es mayor que el de 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 ofrece 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 permite al usuario elegir el margen de error aceptable. Los errores son relativos, por lo que, por ejemplo, la distancia entre 1,0E-5 y 1,00001E-5 dará como resultado 110, mientras que la distancia entre 1,0E36 y 1,00001E36 dará como resultado 127.

Esta función resulta útil cuando una comparación de números de 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 ofrece resultados significativos si alguno de los argumentos es Infinite o NaN. Puedes comprobarlo llamando a qIsFinite().

El valor devuelto puede considerarse como el «error», por lo que, si, por ejemplo, quieres comparar dos números de coma flotante de 32 bits y solo necesitas una precisión aproximada de 24 bits, puedes utilizar esta función de la siguiente manera:

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

Véase también qFuzzyCompare().

int qFpClassify(double val)

int qFpClassify(float val)

Clasifica un valor de coma flotante.

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

  • FP_NAN: no es un número
  • FP_INFINITE: infinito (positivo o negativo)
  • FP_ZERO: cero (positivo o negativo)
  • FP_NORMAL: valor finito con mantisa completa
  • FP_SUBNORMAL: valor finito con mantisa reducida

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

Compara los valores de punto flotante p1 y p2 y devuelve true si se consideran iguales; en caso contrario, devuelve false.

Ten en cuenta que la comparación de valores en los que p1 o p2 sea 0,0 no funcionará, ni tampoco la comparación de valores en los que uno de ellos sea NaN o infinito. Si uno de los valores es siempre 0,0, utiliza 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, de modo que cuanto más pequeños sean los números, mayor será la precisión.

Nota: Esta función es segura para subprocesos.

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

Compara los valores de coma flotante p1 y p2 y devuelve true si se consideran iguales; en caso contrario, devuelve false.

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

Nota: Esta función es segura para subprocesos.

[constexpr noexcept] bool qFuzzyIsNull(double d)

Devuelve «true» si el valor absoluto de ` d ` está dentro de un margen de 0,000000000001 respecto a 0,0.

Nota: Esta función es segura para subprocesos.

[constexpr noexcept] bool qFuzzyIsNull(float f)

Devuelve «true» si el valor absoluto de ` f ` está dentro de un margen de 0,00001f respecto a 0,0.

Nota: Esta función es segura para subprocesos.

double qInf()

Devuelve el patrón de bits de un número infinito como un valor de tipo «double».

Véase también ` qIsInf()`.

bool qIsFinite(double d)

Devuelve « true » si el número de tipo «double» d es un número finito.

bool qIsFinite(float f)

Devuelve « true » si el número flotante « f » es un número finito.

bool qIsInf(double d)

Devuelve ` true ` si el valor de tipo `double` ` d ` es equivalente a infinito.

Véase también qInf().

bool qIsInf(float f)

Devuelve ` true ` si el número flotante ` f ` es equivalente a infinito.

Véase también qInf().

bool qIsNaN(double d)

Devuelve « true » si el valor de tipo doble « d » no es un número (NaN).

bool qIsNaN(float f)

Devuelve « true » si el valor de tipo float « 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 almacena 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 los tipos enteros de 8, 16 y 32 bits, así como para los tipos enteros del tamaño de un puntero. Las operaciones matemáticas con desbordamiento para otros tipos, si están disponibles, se consideran 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 valor de tipo double.

Véase también qIsNaN().

[constexpr] qint64 qRound64(double d)

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

Redondea la mitad en sentido contrario a cero (p. ej., 0,5 → 1, -0,5 → -1).

Nota: Esta función no garantiza la exactitud con precisiones elevadas.

Ejemplo:

double valueA = 42949672960.3;
double valueB = 42949672960.7;

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

Nota: Si el valor d está fuera del rango de qint64, el comportamiento es indefinido.

[constexpr] qint64 qRound64(float d)

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

Redondea la mitad alejándola de cero (p. ej., 0,5f → 1, -0,5f → -1).

Nota: Esta función no garantiza la exactitud con precisiones elevadas.

Ejemplo:

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

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

Nota: Si el valor d está fuera del rango de qint64, el comportamiento es indefinido.

[constexpr] int qRound(double d)

Redondea d al entero más cercano.

Redondea la mitad alejándola de cero (p. ej., 0,5 → 1, -0,5 → -1).

Nota: Esta función no garantiza la exactitud en casos de alta precisión.

Ejemplo:

double valueA = 2.3;
double valueB = 2.7;

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

Nota: Si el valor d está fuera del intervalo int, el comportamiento es indefinido.

[constexpr] int qRound(float d)

Redondea d al entero más cercano.

Redondea la mitad alejándola de cero (p. ej., 0,5f → 1, -0,5f → -1).

Nota: Esta función no garantiza la exactitud en casos de alta precisión.

Ejemplo:

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

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

Nota: Si el valor d está fuera del intervalo int, el comportamiento es indefinido.

double qSNaN()

Devuelve el patrón de bits de un NaN de señalización como un valor de tipo «double».

[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 almacena 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 los tipos enteros de 8, 16 y 32 bits, así como para los tipos enteros del tamaño de un puntero. Las operaciones matemáticas de desbordamiento para otros tipos, si están disponibles, se consideran parte de la API privada.

Esta función se introdujo en Qt 6.1.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.