<QtNumeric> - Qt Numeric Functions

Documentation des fonctions

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

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

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)

Ajoute deux valeurs v1 et v2, de type numérique T et stocke le résultat dans result. Si l'addition entraîne un débordement hors de la plage valide pour le type T, la fonction renvoie true; dans le cas contraire, elle renvoie false.

Une implémentation est garantie pour les types entiers de 8, 16 et 32 bits, ainsi que pour les types entiers de la taille d'un pointeur. Les opérations mathématiques en cas de débordement pour les autres types, si elles sont disponibles, sont considérées comme faisant partie de l'API privée.

Cette fonction a été introduite dans Qt 6.1.

quint64 qFloatDistance(double a, double b)

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

Cette fonction a la même utilité que qFloatDistance(float, float), mais renvoie la distance entre deux nombres de type double. La plage étant plus large que pour deux nombres de type 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 compris entre a et b.

Cette fonction offre une autre méthode pour effectuer des comparaisons approximatives de nombres à virgule flottante, similaire à qFuzzyCompare(). Cependant, elle renvoie la distance entre deux nombres, ce qui permet à l'appelant de choisir le seuil d'erreur acceptable. Les erreurs sont relatives ; ainsi, par exemple, la distance entre 1,0E-5 et 1,00001E-5 donnera 110, tandis que la distance entre 1,0E36 et 1,00001E36 donnera 127.

Cette fonction est utile lorsqu’une comparaison de nombres à virgule flottante nécessite une certaine précision. Ainsi, si a et b sont égaux, elle renverra 0. La valeur maximale qu’elle renverra pour des nombres à virgule flottante sur 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 vérifier cela en appelant la fonction qIsFinite().

La valeur de retour peut être considérée comme l’« erreur » ; ainsi, si vous souhaitez par exemple comparer deux nombres à virgule flottante de 32 bits et que vous n’avez besoin que d’une précision approximative de 24 bits, vous pouvez utiliser cette fonction comme suit :

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

Voir également qFuzzyCompare().

Classifie une valeur à virgule flottante.

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

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

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

Compare les valeurs à 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 est égal à 0,0 ne fonctionnera pas, pas plus que la comparaison de valeurs dont l'une est NaN ou infinie. Si l'une des valeurs est toujours égale à 0,0, utilisez plutôt qFuzzyIsNull. Si l'une des valeurs est susceptible d'être égale à 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

La comparaison des deux nombres s’effectue de manière relative : plus les nombres sont petits, plus la précision est grande.

Remarque : cette fonction est thread-safe.

[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.

La comparaison des deux nombres s'effectue de manière relative : plus les nombres sont petits, plus la précision est grande.

Remarque : cette fonction est thread-safe.

[constexpr noexcept] bool qFuzzyIsNull(double d)

Renvoie « true » si la valeur absolue de ` d ` se situe à moins de 0,000000000001 de 0,0.

Remarque : cette fonction est thread-safe.

[constexpr noexcept] bool qFuzzyIsNull(float f)

Renvoie « true » si la valeur absolue de ` f ` est comprise dans un intervalle de 0,00001f autour de 0,0.

Remarque : cette fonction est thread-safe.

double qInf()

Renvoie le motif binaire d'un nombre infini sous forme de nombre de type double.

Voir aussi qIsInf().

bool qIsFinite(double d)

Renvoie ` true ` si le nombre à deux décimales d est un nombre fini.

bool qIsFinite(float f)

Renvoie « true » si la valeur flottante f est un nombre fini.

bool qIsInf(double d)

Renvoie « true » si la valeur double « d » est égale à l'infini.

Voir également qInf().

bool qIsInf(float f)

Renvoie ` true ` si la valeur flottante ` f ` est égale à l'infini.

Voir aussi qInf().

bool qIsNaN(double d)

Renvoie « true » si la valeur double d n'est pas un nombre (NaN).

bool qIsNaN(float f)

Renvoie « true » si la valeur de type float « 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, puis stocke la valeur résultante dans result. Si la multiplication dépasse la plage valide pour le type T, renvoie true; sinon, renvoie false.

Une implémentation est garantie pour les types entiers 8, 16 et 32 bits, ainsi que pour les types 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 faisant partie de l’API privée.

Cette fonction a été introduite dans Qt 6.1.

double qQNaN()

Renvoie le motif binaire d'un NaN « silencieux » sous forme de nombre à virgule flottante de type double.

Voir également qIsNaN().

[constexpr] qint64 qRound64(double d)

Arrondit la valeur « d » à l'entier de 64 bits le plus proche.

Arrondit la moitié dans le sens opposé à 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 la valeur « d » à l'entier de 64 bits le plus proche.

Arrondit les demi-valeurs en s'éloignant 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 la valeur « d » à l'entier le plus proche.

Arrondit en s'éloignant 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.

Arrondit les demi-valeurs dans le sens opposé à 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 motif binaire d'une valeur NaN de signalisation sous forme de nombre à virgule flottante de type 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 stocke la valeur résultante dans result. Si la soustraction entraîne un débordement hors de la plage valide pour le type T, la fonction renvoie true; sinon, elle renvoie false.

Une implémentation est garantie pour les types entiers de 8, 16 et 32 bits, ainsi que pour les types entiers de la taille d’un pointeur. Les opérations mathématiques en cas de dépassement de capacité pour les autres types, si elles sont disponibles, sont considérées comme faisant partie de l’API privée.

Cette fonction a été introduite dans Qt 6.1.