<QtNumeric> - Qt Numeric Functions

Documentation des fonctions

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

Compare t au 0 de type T et renvoie la valeur absolue. Ainsi, si T est un double, t est comparé au (double) 0.

Exemple :

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)

Additionne deux valeurs v1 et v2, d'un type numérique T et enregistre la valeur dans result. Si l'addition dépasse la plage valide pour le type T, elle renvoie true, sinon elle renvoie false.

La disponibilité d'une implémentation est garantie pour les types d'entiers de 8, 16 et 32 bits, ainsi que pour les types d'entiers de la taille d'un pointeur. Les calculs de débordement pour les autres types, s'ils sont disponibles, sont considérés comme des API privées.

Cette fonction a été introduite dans Qt 6.1.

quint64 qFloatDistance(double a, double b)

Renvoie le nombre de nombres représentables en virgule flottante entre a et b.

Cette fonction a le même objectif que qFloatDistance(float, float), mais elle renvoie la distance entre deux nombres double. Comme l'intervalle est plus grand que pour deux nombres float ([-DBL_MAX,DBL_MAX]), le type de retour est quint64.

Voir également qFuzzyCompare().

quint32 qFloatDistance(float a, float b)

Renvoie le nombre de nombres à virgule flottante représentables entre a et b.

Cette fonction fournit une alternative pour effectuer des comparaisons approximatives de nombres à virgule flottante similaires à qFuzzyCompare(). Cependant, elle renvoie la distance entre deux nombres, ce qui permet à l'appelant de choisir l'erreur acceptée. Les erreurs sont relatives, par exemple la distance entre 1.0E-5 et 1.00001E-5 donnera 110, alors que la distance entre 1.0E36 et 1.00001E36 donnera 127.

Cette fonction est utile si une comparaison en virgule flottante exige une certaine précision. Ainsi, si a et b sont égaux, elle renverra 0. La valeur maximale qu'elle renvoie pour les nombres à virgule flottante de 32 bits est 4 278 190 078. Il s'agit de la distance entre -FLT_MAX et +FLT_MAX.

La fonction ne donne pas de résultats significatifs si l'un des arguments est Infinite ou NaN. Vous pouvez le vérifier en appelant qIsFinite().

La valeur de retour peut être considérée comme une "erreur". Ainsi, si vous souhaitez par exemple comparer deux nombres à virgule flottante de 32 bits et que tout ce dont vous avez besoin est une précision approximative de 24 bits, vous pouvez utiliser cette fonction de la manière suivante :

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

Voir aussi qFuzzyCompare().

Classifie une valeur en virgule flottante.

Les valeurs de retour sont définies dans <cmath>: renvoie l'une des valeurs suivantes, déterminée par la classe de virgule flottante de val:

• FP_NAN pas un nombre
• FP_INFINITE infini (positif ou négatif)
• FP_ZERO zéro (positif ou négatif)
• FP_NORMAL fini avec une mantisse complète
• FP_SUBNORMAL fini avec une mantisse réduite

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

Compare les valeurs en virgule flottante p1 et p2 et renvoie true si elles sont considérées comme égales, sinon false.

Notez que la comparaison de valeurs pour lesquelles p1 ou p2 vaut 0,0 ne fonctionne pas, pas plus que la comparaison de valeurs pour lesquelles l'une des valeurs est NaN ou infinie. Si l'une des valeurs est toujours 0,0, utilisez plutôt qFuzzyIsNull. Si l'une des valeurs est susceptible d'être 0,0, une solution consiste à ajouter 1,0 aux deux valeurs.

// 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

Les deux nombres sont comparés de manière relative, l'exactitude étant d'autant plus grande que les nombres sont petits.

Remarque : cette fonction est sécurisée pour les threads.

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

Compare les valeurs à virgule flottante p1 et p2 et renvoie true si elles sont considérées comme égales, sinon false.

Les deux nombres sont comparés de manière relative, l'exactitude étant d'autant plus grande que les nombres sont petits.

Remarque : cette fonction est à l'épreuve des threads.

[constexpr noexcept] bool qFuzzyIsNull(double d)

Renvoie un résultat positif si la valeur absolue de d se situe à 0,000000000001 près de 0,0.

Remarque : cette fonction est à l'épreuve des threads.

[constexpr noexcept] bool qFuzzyIsNull(float f)

Renvoie un résultat positif si la valeur absolue de f est inférieure à 0,00001f de 0,0.

Remarque : cette fonction n'est pas sujette aux threads.

double qInf()

Renvoie le schéma de bits d'un nombre infini sous la forme d'un double.

Voir aussi qIsInf().

bool qIsFinite(double d)

Renvoie true si le double d est un nombre fini.

bool qIsFinite(float f)

Renvoie true si le flottant f est un nombre fini.

bool qIsInf(double d)

Renvoie true si le double d est équivalent à l'infini.

Voir aussi qInf().

bool qIsInf(float f)

Renvoie true si le flottant f est équivalent à l'infini.

Voir aussi qInf().

bool qIsNaN(double d)

Renvoie true si le double d n'est pas un nombre (NaN).

bool qIsNaN(float f)

Renvoie true si le flottant f n'est pas un nombre (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)

Multiplie v1 et v2, et enregistre la valeur résultante dans result. Si la multiplication dépasse la plage valide pour le type T, renvoie true, sinon renvoie false.

La disponibilité d'une implémentation est garantie pour les types d'entiers de 8, 16 et 32 bits, ainsi que pour les types d'entiers de la taille d'un pointeur. Les calculs de débordement pour les autres types, s'ils sont disponibles, sont considérés comme des API privées.

Cette fonction a été introduite dans Qt 6.1.

double qQNaN()

Renvoie le schéma binaire d'un NaN silencieux sous la forme d'un double.

Voir aussi qIsNaN().

[constexpr] qint64 qRound64(double d)

Arrondit d à l'entier 64 bits le plus proche.

Les arrondis s'éloignent de moitié de zéro (par exemple, 0,5 -> 1, -0,5 -> -1).

Exemple :

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)

Arrondit d à l'entier 64 bits le plus proche.

Les arrondis s'éloignent de moitié de zéro (par exemple, 0,5f -> 1, -0,5f -> -1).

Exemple :

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)

Arrondit d à l'entier le plus proche.

Les arrondis s'éloignent de moitié de zéro (par exemple, 0,5 -> 1, -0,5 -> -1).

Exemple :

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)

Arrondit d à l'entier le plus proche.

Les arrondis s'éloignent de moitié de zéro (par exemple, 0,5f -> 1, -0,5f -> -1).

Exemple :

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

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

double qSNaN()

Renvoie le schéma binaire d'un NaN de signalisation sous la forme d'un 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)

Soustrait v2 de v1 et enregistre la valeur résultante dans result. Si la soustraction dépasse la plage valide pour le type T, elle renvoie true, sinon elle renvoie false.

La disponibilité d'une implémentation est garantie pour les types d'entiers de 8, 16 et 32 bits, ainsi que pour les types d'entiers de la taille d'un pointeur. Les calculs de débordement pour les autres types, s'ils sont disponibles, sont considérés comme des API privées.

Cette fonction a été introduite dans Qt 6.1.