<QtNumeric> - Qt Numeric Functions

Funktion Dokumentation

Klassifiziert eine Fließkommazahl.

Die Rückgabewerte sind in <cmath> definiert: gibt einen der folgenden Werte zurück, bestimmt durch die Fließkommaklasse von val:

• FP_NAN keine Zahl
• FP_INFINITE Unendlichkeiten (positiv oder negativ)
• FP_ZERO Null (positiv oder negativ)
• FP_NORMAL endlich mit einer vollen Mantisse
• FP_SUBNORMAL endlich mit reduzierter Mantisse

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

Vergleicht t mit der 0 des Typs T und gibt den absoluten Wert zurück. Wenn also T double ist, dann wird t mit (double) 0 verglichen.

Beispiel:

int absoluteValue;
int myValue = -4;

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

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

Addiert zwei Werte v1 und v2 eines numerischen Typs T und speichert den Wert in result. Wenn die Addition den gültigen Bereich für den Typ T überschreitet, wird true zurückgegeben, andernfalls false.

Es ist garantiert, dass eine Implementierung für 8-, 16- und 32-Bit-Ganzzahltypen sowie Ganzzahltypen mit der Größe eines Zeigers verfügbar ist. Überlaufmathematik für andere Typen, falls verfügbar, wird als private API betrachtet.

Diese Funktion wurde in Qt 6.1 eingeführt.

quint64 qFloatDistance(double a, double b)

Gibt die Anzahl der darstellbaren Fließkommazahlen zwischen a und b zurück.

Diese Funktion dient demselben Zweck wie qFloatDistance(float, float), gibt aber den Abstand zwischen zwei double Zahlen zurück. Da der Bereich größer ist als bei zwei float Zahlen ([-DBL_MAX,DBL_MAX]), ist der Rückgabetyp quint64.

Siehe auch qFuzzyCompare().

quint32 qFloatDistance(float a, float b)

Gibt die Anzahl der darstellbaren Fließkommazahlen zwischen a und b zurück.

Diese Funktion bietet einen alternativen Weg für annähernde Vergleiche von Fließkommazahlen ähnlich wie qFuzzyCompare(). Sie gibt jedoch den Abstand zwischen zwei Zahlen zurück, was dem Aufrufer die Möglichkeit gibt, den akzeptierten Fehler zu wählen. Die Fehler sind relativ, so dass z.B. der Abstand zwischen 1.0E-5 und 1.00001E-5 110 ergibt, während der Abstand zwischen 1.0E36 und 1.00001E36 127 ergibt.

Diese Funktion ist nützlich, wenn ein Fließkomma-Vergleich eine bestimmte Genauigkeit erfordert. Wenn also a und b gleich sind, gibt sie 0 zurück. Der maximale Wert, den sie für 32-Bit-Gleitkommazahlen zurückgibt, ist 4.278.190.078. Dies ist der Abstand zwischen -FLT_MAX und +FLT_MAX.

Die Funktion liefert keine aussagekräftigen Ergebnisse, wenn eines der Argumente Infinite oder NaN ist. Sie können dies überprüfen, indem Sie qIsFinite() aufrufen.

Der Rückgabewert kann als "Fehler" betrachtet werden. Wenn Sie also z. B. zwei 32-Bit-Gleitkommazahlen vergleichen wollen und nur eine angenäherte 24-Bit-Präzision benötigen, können Sie diese Funktion wie folgt verwenden:

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

Siehe auch qFuzzyCompare().

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

Vergleicht die Fließkommazahlen p1 und p2 und gibt true zurück, wenn sie als gleich angesehen werden, andernfalls false.

Beachten Sie, dass der Vergleich von Werten, bei denen entweder p1 oder p2 0,0 ist, nicht funktioniert, ebenso wenig wie der Vergleich von Werten, bei denen einer der Werte NaN oder unendlich ist. Wenn einer der Werte immer 0,0 ist, verwenden Sie stattdessen qFuzzyIsNull. Wenn einer der Werte wahrscheinlich 0,0 ist, besteht eine Lösung darin, zu beiden Werten 1,0 zu addieren.

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

Die beiden Zahlen werden auf relative Weise verglichen, wobei die Genauigkeit umso größer ist, je kleiner die Zahlen sind.

Hinweis: Diese Funktion ist thread-sicher.

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

Vergleicht die Fließkommazahlen p1 und p2 und gibt true zurück, wenn sie als gleich angesehen werden, andernfalls false.

Die beiden Zahlen werden relativ verglichen, wobei die Genauigkeit umso größer ist, je kleiner die Zahlen sind.

Hinweis: Diese Funktion ist thread-sicher.

[constexpr noexcept] bool qFuzzyIsNull(double d)

Gibt true zurück, wenn der absolute Wert von d innerhalb von 0.000000000001 von 0.0 liegt.

Hinweis: Diese Funktion ist thread-sicher.

[constexpr noexcept] bool qFuzzyIsNull(float f)

Gibt true zurück, wenn der absolute Wert von f innerhalb von 0,00001f von 0,0 liegt.

Hinweis: Diese Funktion ist thread-sicher.

double qInf()

Gibt das Bitmuster für eine unendliche Zahl als Double zurück.

Siehe auch qIsInf().

bool qIsFinite(double d)

Gibt true zurück, wenn das Double d eine endliche Zahl ist.

bool qIsFinite(float f)

Gibt true zurück, wenn der Float f eine endliche Zahl ist.

bool qIsInf(double d)

Gibt true zurück, wenn das Double d äquivalent zur Unendlichkeit ist.

Siehe auch qInf().

bool qIsInf(float f)

Gibt true zurück, wenn der Float f gleich unendlich ist.

Siehe auch qInf().

bool qIsNaN(double d)

Gibt true zurück, wenn der Double d keine Zahl (NaN) ist.

bool qIsNaN(float f)

Gibt true zurück, wenn der Float f keine Zahl (NaN) ist.

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

Multipliziert v1 und v2 und speichert den resultierenden Wert in result. Wenn die Multiplikation den gültigen Bereich für den Typ T überschreitet, wird true zurückgegeben, andernfalls false.

Es ist garantiert, dass eine Implementierung für 8-, 16- und 32-Bit-Ganzzahltypen sowie Ganzzahltypen mit der Größe eines Zeigers verfügbar ist. Überlaufmathematik für andere Typen, falls verfügbar, wird als private API betrachtet.

Diese Funktion wurde in Qt 6.1 eingeführt.

double qQNaN()

Gibt das Bitmuster eines ruhigen NaN als Double zurück.

Siehe auch qIsNaN().

[constexpr] qint64 qRound64(double d)

Rundet d auf die nächstliegende 64-Bit-Ganzzahl.

Rundet die Hälfte von Null weg (z. B. 0,5 -> 1, -0,5 -> -1).

Beispiel:

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)

Rundet d auf die nächstliegende 64-Bit-Ganzzahl.

Rundet die Hälfte von Null weg (z.B. 0.5f -> 1, -0.5f -> -1).

Beispiel:

float valueA = 42949672960.3;
float valueB = 42949672960.7;

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

[constexpr] int qRound(double d)

Rundet d auf die nächstliegende ganze Zahl.

Rundet die Hälfte von Null weg (z.B. 0.5 -> 1, -0.5 -> -1).

Beispiel:

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)

Rundet d auf die nächstliegende ganze Zahl.

Rundet die Hälfte von Null weg (z.B. 0.5f -> 1, -0.5f -> -1).

Beispiel:

float valueA = 2.3;
float valueB = 2.7;

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

double qSNaN()

Gibt das Bitmuster eines signalisierenden NaN als Double zurück.

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

Subtrahiert v2 von v1 und speichert den resultierenden Wert in result. Wenn die Subtraktion den gültigen Bereich für den Typ T überschreitet, wird true zurückgegeben, andernfalls false.

Es ist garantiert, dass eine Implementierung für 8-, 16- und 32-Bit-Ganzzahltypen sowie Ganzzahltypen mit der Größe eines Zeigers verfügbar ist. Überlaufmathematik für andere Typen, falls verfügbar, wird als private API betrachtet.

Diese Funktion wurde in Qt 6.1 eingeführt.