<QtNumeric> - Qt Numeric Functions

Funktionsdokumentation

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

Vergleicht „ t “ mit der 0 vom Typ T und gibt den Absolutwert zurück. Ist T also vom Typ „double“, wird „ t “ mit (double) 0 verglichen.

Beispiel:

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)

Addiert zwei Werte „ v1 “ und „ v2 “ vom numerischen Typ „ 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 “.

Eine Implementierung ist garantiert für 8-, 16- und 32-Bit-Ganzzahltypen sowie für Ganzzahltypen der Größe eines Zeigers verfügbar. Überlaufberechnungen für andere Typen gelten, sofern verfügbar, als private API.

Diese Funktion wurde in Qt 6.1 eingeführt.

quint64 qFloatDistance(double a, double b)

Gibt die Anzahl der darstellbaren Gleitkommazahlen zwischen a und b zurück.

Diese Funktion erfüllt denselben Zweck wie ` qFloatDistance(float, float)`, gibt jedoch 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 Gleitkommazahlen zwischen a und b zurück.

Diese Funktion bietet eine alternative Möglichkeit, Gleitkommazahlen ähnlich wie mit qFuzzyCompare() annähernd zu vergleichen. Sie gibt jedoch den Abstand zwischen zwei Zahlen zurück, wodurch der Aufrufer die Möglichkeit hat, den akzeptierten Fehler selbst zu wählen. Fehler sind relativ, sodass beispielsweise der Abstand zwischen 1,0E-5 und 1,00001E-5 den Wert 110 ergibt, während der Abstand zwischen 1,0E36 und 1,00001E36 den Wert 127 ergibt.

Diese Funktion ist nützlich, wenn ein Gleitkomma-Vergleich eine bestimmte Genauigkeit erfordert. Sind also a und b gleich, gibt die Funktion 0 zurück. Der maximale Wert, den sie für 32-Bit-Gleitkommazahlen zurückgibt, beträgt 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 beispielsweise zwei 32-Bit-Gleitkommazahlen vergleichen möchten und lediglich eine ungefähre 24-Bit-Genauigkeit 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().

Klassifiziert einen Gleitkommawert.

Die Rückgabewerte sind in „ <cmath> “ definiert: Es wird einer der folgenden Werte zurückgegeben, der von der Gleitkomma-Klasse von „ val “ bestimmt wird:

• FP_NAN – keine Zahl
• FP_INFINITE Unendlichkeiten (positiv oder negativ)
• FP_ZERO: Null (positiv oder negativ)
• FP_NORMAL: endlich mit vollständiger Mantisse
• FP_SUBNORMAL: endlicher Wert mit reduzierter Mantisse

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

Vergleicht die Gleitkommawerte 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 den Wert 0,0 hat, 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 hinzuzufügen.

// 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 relativ zueinander verglichen, wobei die Genauigkeit umso höher ist, je kleiner die Zahlen sind.

Hinweis: Diese Funktion ist threadsicher.

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

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

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

Hinweis: Diese Funktion ist threadsicher.

[constexpr noexcept] bool qFuzzyIsNull(double d)

Gibt „true“ zurück, wenn der Absolutwert von ` d ` innerhalb von 0,000000000001 von 0,0 liegt.

Hinweis: Diese Funktion ist threadsicher.

[constexpr noexcept] bool qFuzzyIsNull(float f)

Gibt „true“ zurück, wenn der Absolutwert von ` f ` innerhalb von 0,00001f von 0,0 liegt.

Hinweis: Diese Funktion ist threadsicher.

double qInf()

Gibt das Bitmuster einer unendlichen Zahl als Double-Wert zurück.

Siehe auch ` qIsInf()`.

bool qIsFinite(double d)

Gibt „ true “ zurück, wenn die Double-Zahl „ d “ eine endliche Zahl ist.

bool qIsFinite(float f)

Gibt „ true “ zurück, wenn die Float-Zahl „ f “ eine endliche Zahl ist.

bool qIsInf(double d)

Gibt „ true “ zurück, wenn der Double-Wert „ d “ gleich unendlich ist.

Siehe auch qInf().

bool qIsInf(float f)

Gibt „ true “ zurück, wenn der Float-Wert „ f “ gleich unendlich ist.

Siehe auch qInf().

bool qIsNaN(double d)

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

bool qIsNaN(float f)

Gibt „ true “ zurück, wenn der Float-Wert „ f “ keine Zahl ist (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)

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.

Eine Implementierung ist garantiert für 8-, 16- und 32-Bit-Ganzzahltypen sowie für Ganzzahltypen der Größe eines Zeigers verfügbar. Überlaufberechnungen für andere Typen gelten, sofern verfügbar, als private API.

Diese Funktion wurde in Qt 6.1 eingeführt.

double qQNaN()

Gibt das Bitmuster eines „quiet NaN“ als Double-Wert zurück.

Siehe auch „ qIsNaN()“.

[constexpr] qint64 qRound64(double d)

Rundet „ d “ auf die nächste 64-Bit-Ganzzahl.

Rundet in Richtung weg von Null (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ächste 64-Bit-Ganzzahl.

Rundet in Richtung weg von Null (z. B. 0,5f -> 1, -0,5f -> -1).

Beispiel:

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)

Rundet „ d “ auf die nächste ganze Zahl.

Rundet die Hälfte weg von Null (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ächste ganze Zahl.

Rundet Halbwerte weg von Null (z. B. 0,5f -> 1, -0,5f -> -1).

Beispiel:

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

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

double qSNaN()

Gibt das Bitmuster eines signalgebenden NaN als Double-Wert zurück.

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

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.

Eine Implementierung ist garantiert für 8-, 16- und 32-Bit-Ganzzahltypen sowie für Ganzzahltypen der Größe eines Zeigers verfügbar. Überlaufberechnungen für andere Typen gelten, sofern verfügbar, als private API.

Diese Funktion wurde in Qt 6.1 eingeführt.