345 lines
14 KiB
C++
345 lines
14 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2019 The Qt Company Ltd.
|
|
** Copyright (C) 2016 by Southwest Research Institute (R)
|
|
** Contact: http://www.qt-project.org/legal
|
|
**
|
|
** This file is part of the QtCore module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef QFLOAT16_H
|
|
#define QFLOAT16_H
|
|
|
|
#include <QtCore/qglobal.h>
|
|
#include <QtCore/qmetatype.h>
|
|
#include <string.h>
|
|
|
|
#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__AVX2__) && !defined(__F16C__)
|
|
// All processors that support AVX2 do support F16C too. That doesn't mean
|
|
// we're allowed to use the intrinsics directly, so we'll do it only for
|
|
// the Intel and Microsoft's compilers.
|
|
# if defined(Q_CC_INTEL) || defined(Q_CC_MSVC)
|
|
# define __F16C__ 1
|
|
# endif
|
|
#endif
|
|
|
|
#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)
|
|
#include <immintrin.h>
|
|
#endif
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
#if 0
|
|
#pragma qt_class(QFloat16)
|
|
#pragma qt_no_master_include
|
|
#endif
|
|
|
|
class qfloat16
|
|
{
|
|
struct Wrap
|
|
{
|
|
// To let our private constructor work, without other code seeing
|
|
// ambiguity when constructing from int, double &c.
|
|
quint16 b16;
|
|
constexpr inline explicit Wrap(int value) : b16(value) {}
|
|
};
|
|
public:
|
|
constexpr inline qfloat16() noexcept : b16(0) {}
|
|
inline qfloat16(float f) noexcept;
|
|
inline operator float() const noexcept;
|
|
|
|
// Support for qIs{Inf,NaN,Finite}:
|
|
bool isInf() const noexcept { return ((b16 >> 8) & 0x7e) == 0x7c; }
|
|
bool isNaN() const noexcept { return ((b16 >> 8) & 0x7e) == 0x7e; }
|
|
bool isFinite() const noexcept { return ((b16 >> 8) & 0x7c) != 0x7c; }
|
|
Q_CORE_EXPORT int fpClassify() const noexcept;
|
|
// Support for std::numeric_limits<qfloat16>
|
|
static constexpr qfloat16 _limit_epsilon() noexcept { return qfloat16(Wrap(0x1400)); }
|
|
static constexpr qfloat16 _limit_min() noexcept { return qfloat16(Wrap(0x400)); }
|
|
static constexpr qfloat16 _limit_denorm_min() noexcept { return qfloat16(Wrap(1)); }
|
|
static constexpr qfloat16 _limit_max() noexcept { return qfloat16(Wrap(0x7bff)); }
|
|
static constexpr qfloat16 _limit_lowest() noexcept { return qfloat16(Wrap(0xfbff)); }
|
|
static constexpr qfloat16 _limit_infinity() noexcept { return qfloat16(Wrap(0x7c00)); }
|
|
static constexpr qfloat16 _limit_quiet_NaN() noexcept { return qfloat16(Wrap(0x7e00)); }
|
|
// Signalling NaN is 0x7f00
|
|
inline constexpr bool isNormal() const noexcept
|
|
{ return (b16 & 0x7fff) == 0 || ((b16 & 0x7c00) && (b16 & 0x7c00) != 0x7c00); }
|
|
private:
|
|
quint16 b16;
|
|
constexpr inline explicit qfloat16(Wrap nibble) noexcept : b16(nibble.b16) {}
|
|
|
|
Q_CORE_EXPORT static const quint32 mantissatable[];
|
|
Q_CORE_EXPORT static const quint32 exponenttable[];
|
|
Q_CORE_EXPORT static const quint32 offsettable[];
|
|
Q_CORE_EXPORT static const quint32 basetable[];
|
|
Q_CORE_EXPORT static const quint32 shifttable[];
|
|
|
|
friend bool qIsNull(qfloat16 f) noexcept;
|
|
#if !defined(QT_NO_FLOAT16_OPERATORS)
|
|
friend qfloat16 operator-(qfloat16 a) noexcept;
|
|
#endif
|
|
};
|
|
|
|
Q_DECLARE_TYPEINFO(qfloat16, Q_PRIMITIVE_TYPE);
|
|
|
|
Q_CORE_EXPORT void qFloatToFloat16(qfloat16 *, const float *, qsizetype length) noexcept;
|
|
Q_CORE_EXPORT void qFloatFromFloat16(float *, const qfloat16 *, qsizetype length) noexcept;
|
|
|
|
// Complement qnumeric.h:
|
|
Q_REQUIRED_RESULT inline bool qIsInf(qfloat16 f) noexcept { return f.isInf(); }
|
|
Q_REQUIRED_RESULT inline bool qIsNaN(qfloat16 f) noexcept { return f.isNaN(); }
|
|
Q_REQUIRED_RESULT inline bool qIsFinite(qfloat16 f) noexcept { return f.isFinite(); }
|
|
Q_REQUIRED_RESULT inline int qFpClassify(qfloat16 f) noexcept { return f.fpClassify(); }
|
|
// Q_REQUIRED_RESULT quint32 qFloatDistance(qfloat16 a, qfloat16 b);
|
|
|
|
// The remainder of these utility functions complement qglobal.h
|
|
Q_REQUIRED_RESULT inline int qRound(qfloat16 d) noexcept
|
|
{ return qRound(static_cast<float>(d)); }
|
|
|
|
Q_REQUIRED_RESULT inline qint64 qRound64(qfloat16 d) noexcept
|
|
{ return qRound64(static_cast<float>(d)); }
|
|
|
|
Q_REQUIRED_RESULT inline bool qFuzzyCompare(qfloat16 p1, qfloat16 p2) noexcept
|
|
{
|
|
float f1 = static_cast<float>(p1);
|
|
float f2 = static_cast<float>(p2);
|
|
// The significand precision for IEEE754 half precision is
|
|
// 11 bits (10 explicitly stored), or approximately 3 decimal
|
|
// digits. In selecting the fuzzy comparison factor of 102.5f
|
|
// (that is, (2^10+1)/10) below, we effectively select a
|
|
// window of about 1 (least significant) decimal digit about
|
|
// which the two operands can vary and still return true.
|
|
return (qAbs(f1 - f2) * 102.5f <= qMin(qAbs(f1), qAbs(f2)));
|
|
}
|
|
|
|
Q_REQUIRED_RESULT inline bool qIsNull(qfloat16 f) noexcept
|
|
{
|
|
return (f.b16 & static_cast<quint16>(0x7fff)) == 0;
|
|
}
|
|
|
|
inline int qIntCast(qfloat16 f) noexcept
|
|
{ return int(static_cast<float>(f)); }
|
|
|
|
#ifndef Q_QDOC
|
|
QT_WARNING_PUSH
|
|
QT_WARNING_DISABLE_CLANG("-Wc99-extensions")
|
|
QT_WARNING_DISABLE_GCC("-Wold-style-cast")
|
|
inline qfloat16::qfloat16(float f) noexcept
|
|
{
|
|
#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)
|
|
__m128 packsingle = _mm_set_ss(f);
|
|
__m128i packhalf = _mm_cvtps_ph(packsingle, 0);
|
|
b16 = _mm_extract_epi16(packhalf, 0);
|
|
#elif defined (__ARM_FP16_FORMAT_IEEE)
|
|
__fp16 f16 = __fp16(f);
|
|
memcpy(&b16, &f16, sizeof(quint16));
|
|
#else
|
|
quint32 u;
|
|
memcpy(&u, &f, sizeof(quint32));
|
|
b16 = basetable[(u >> 23) & 0x1ff]
|
|
+ ((u & 0x007fffff) >> shifttable[(u >> 23) & 0x1ff]);
|
|
#endif
|
|
}
|
|
QT_WARNING_POP
|
|
|
|
inline qfloat16::operator float() const noexcept
|
|
{
|
|
#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)
|
|
__m128i packhalf = _mm_cvtsi32_si128(b16);
|
|
__m128 packsingle = _mm_cvtph_ps(packhalf);
|
|
return _mm_cvtss_f32(packsingle);
|
|
#elif defined (__ARM_FP16_FORMAT_IEEE)
|
|
__fp16 f16;
|
|
memcpy(&f16, &b16, sizeof(quint16));
|
|
return float(f16);
|
|
#else
|
|
quint32 u = mantissatable[offsettable[b16 >> 10] + (b16 & 0x3ff)]
|
|
+ exponenttable[b16 >> 10];
|
|
float f;
|
|
memcpy(&f, &u, sizeof(quint32));
|
|
return f;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#if !defined(QT_NO_FLOAT16_OPERATORS)
|
|
inline qfloat16 operator-(qfloat16 a) noexcept
|
|
{
|
|
qfloat16 f;
|
|
f.b16 = a.b16 ^ quint16(0x8000);
|
|
return f;
|
|
}
|
|
|
|
inline qfloat16 operator+(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) + static_cast<float>(b)); }
|
|
inline qfloat16 operator-(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) - static_cast<float>(b)); }
|
|
inline qfloat16 operator*(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) * static_cast<float>(b)); }
|
|
inline qfloat16 operator/(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) / static_cast<float>(b)); }
|
|
|
|
#define QF16_MAKE_ARITH_OP_FP(FP, OP) \
|
|
inline FP operator OP(qfloat16 lhs, FP rhs) noexcept { return static_cast<FP>(lhs) OP rhs; } \
|
|
inline FP operator OP(FP lhs, qfloat16 rhs) noexcept { return lhs OP static_cast<FP>(rhs); }
|
|
#define QF16_MAKE_ARITH_OP_EQ_FP(FP, OP_EQ, OP) \
|
|
inline qfloat16& operator OP_EQ(qfloat16& lhs, FP rhs) noexcept \
|
|
{ lhs = qfloat16(float(static_cast<FP>(lhs) OP rhs)); return lhs; }
|
|
#define QF16_MAKE_ARITH_OP(FP) \
|
|
QF16_MAKE_ARITH_OP_FP(FP, +) \
|
|
QF16_MAKE_ARITH_OP_FP(FP, -) \
|
|
QF16_MAKE_ARITH_OP_FP(FP, *) \
|
|
QF16_MAKE_ARITH_OP_FP(FP, /) \
|
|
QF16_MAKE_ARITH_OP_EQ_FP(FP, +=, +) \
|
|
QF16_MAKE_ARITH_OP_EQ_FP(FP, -=, -) \
|
|
QF16_MAKE_ARITH_OP_EQ_FP(FP, *=, *) \
|
|
QF16_MAKE_ARITH_OP_EQ_FP(FP, /=, /)
|
|
QF16_MAKE_ARITH_OP(long double)
|
|
QF16_MAKE_ARITH_OP(double)
|
|
QF16_MAKE_ARITH_OP(float)
|
|
#undef QF16_MAKE_ARITH_OP
|
|
#undef QF16_MAKE_ARITH_OP_FP
|
|
|
|
#define QF16_MAKE_ARITH_OP_INT(OP) \
|
|
inline double operator OP(qfloat16 lhs, int rhs) noexcept { return static_cast<double>(lhs) OP rhs; } \
|
|
inline double operator OP(int lhs, qfloat16 rhs) noexcept { return lhs OP static_cast<double>(rhs); }
|
|
QF16_MAKE_ARITH_OP_INT(+)
|
|
QF16_MAKE_ARITH_OP_INT(-)
|
|
QF16_MAKE_ARITH_OP_INT(*)
|
|
QF16_MAKE_ARITH_OP_INT(/)
|
|
#undef QF16_MAKE_ARITH_OP_INT
|
|
|
|
QT_WARNING_PUSH
|
|
QT_WARNING_DISABLE_CLANG("-Wfloat-equal")
|
|
QT_WARNING_DISABLE_GCC("-Wfloat-equal")
|
|
QT_WARNING_DISABLE_INTEL(1572)
|
|
|
|
inline bool operator>(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) > static_cast<float>(b); }
|
|
inline bool operator<(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) < static_cast<float>(b); }
|
|
inline bool operator>=(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) >= static_cast<float>(b); }
|
|
inline bool operator<=(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) <= static_cast<float>(b); }
|
|
inline bool operator==(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) == static_cast<float>(b); }
|
|
inline bool operator!=(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) != static_cast<float>(b); }
|
|
|
|
#define QF16_MAKE_BOOL_OP_FP(FP, OP) \
|
|
inline bool operator OP(qfloat16 lhs, FP rhs) noexcept { return static_cast<FP>(lhs) OP rhs; } \
|
|
inline bool operator OP(FP lhs, qfloat16 rhs) noexcept { return lhs OP static_cast<FP>(rhs); }
|
|
#define QF16_MAKE_BOOL_OP(FP) \
|
|
QF16_MAKE_BOOL_OP_FP(FP, <) \
|
|
QF16_MAKE_BOOL_OP_FP(FP, >) \
|
|
QF16_MAKE_BOOL_OP_FP(FP, >=) \
|
|
QF16_MAKE_BOOL_OP_FP(FP, <=) \
|
|
QF16_MAKE_BOOL_OP_FP(FP, ==) \
|
|
QF16_MAKE_BOOL_OP_FP(FP, !=)
|
|
QF16_MAKE_BOOL_OP(long double)
|
|
QF16_MAKE_BOOL_OP(double)
|
|
QF16_MAKE_BOOL_OP(float)
|
|
#undef QF16_MAKE_BOOL_OP
|
|
#undef QF16_MAKE_BOOL_OP_FP
|
|
|
|
#define QF16_MAKE_BOOL_OP_INT(OP) \
|
|
inline bool operator OP(qfloat16 a, int b) noexcept { return static_cast<float>(a) OP b; } \
|
|
inline bool operator OP(int a, qfloat16 b) noexcept { return a OP static_cast<float>(b); }
|
|
QF16_MAKE_BOOL_OP_INT(>)
|
|
QF16_MAKE_BOOL_OP_INT(<)
|
|
QF16_MAKE_BOOL_OP_INT(>=)
|
|
QF16_MAKE_BOOL_OP_INT(<=)
|
|
QF16_MAKE_BOOL_OP_INT(==)
|
|
QF16_MAKE_BOOL_OP_INT(!=)
|
|
#undef QF16_MAKE_BOOL_OP_INT
|
|
|
|
QT_WARNING_POP
|
|
#endif // QT_NO_FLOAT16_OPERATORS
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
Q_REQUIRED_RESULT inline bool qFuzzyIsNull(qfloat16 f) noexcept
|
|
{
|
|
return qAbs(static_cast<float>(f)) <= 0.001f;
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
Q_DECLARE_METATYPE(qfloat16)
|
|
|
|
namespace std {
|
|
template<>
|
|
class numeric_limits<QT_PREPEND_NAMESPACE(qfloat16)> : public numeric_limits<float>
|
|
{
|
|
public:
|
|
/*
|
|
Treat quint16 b16 as if it were:
|
|
uint S: 1; // b16 >> 15 (sign); can be set for zero
|
|
uint E: 5; // (b16 >> 10) & 0x1f (offset exponent)
|
|
uint M: 10; // b16 & 0x3ff (adjusted mantissa)
|
|
|
|
for E == 0: magnitude is M / 2.^{24}
|
|
for 0 < E < 31: magnitude is (1. + M / 2.^{10}) * 2.^{E - 15)
|
|
for E == 31: not finite
|
|
*/
|
|
static constexpr int digits = 11;
|
|
static constexpr int min_exponent = -13;
|
|
static constexpr int max_exponent = 16;
|
|
|
|
static constexpr int digits10 = 3;
|
|
static constexpr int max_digits10 = 5;
|
|
static constexpr int min_exponent10 = -4;
|
|
static constexpr int max_exponent10 = 4;
|
|
|
|
static constexpr QT_PREPEND_NAMESPACE(qfloat16) epsilon()
|
|
{ return QT_PREPEND_NAMESPACE(qfloat16)::_limit_epsilon(); }
|
|
static constexpr QT_PREPEND_NAMESPACE(qfloat16) (min)()
|
|
{ return QT_PREPEND_NAMESPACE(qfloat16)::_limit_min(); }
|
|
static constexpr QT_PREPEND_NAMESPACE(qfloat16) denorm_min()
|
|
{ return QT_PREPEND_NAMESPACE(qfloat16)::_limit_denorm_min(); }
|
|
static constexpr QT_PREPEND_NAMESPACE(qfloat16) (max)()
|
|
{ return QT_PREPEND_NAMESPACE(qfloat16)::_limit_max(); }
|
|
static constexpr QT_PREPEND_NAMESPACE(qfloat16) lowest()
|
|
{ return QT_PREPEND_NAMESPACE(qfloat16)::_limit_lowest(); }
|
|
static constexpr QT_PREPEND_NAMESPACE(qfloat16) infinity()
|
|
{ return QT_PREPEND_NAMESPACE(qfloat16)::_limit_infinity(); }
|
|
static constexpr QT_PREPEND_NAMESPACE(qfloat16) quiet_NaN()
|
|
{ return QT_PREPEND_NAMESPACE(qfloat16)::_limit_quiet_NaN(); }
|
|
};
|
|
|
|
template<> class numeric_limits<const QT_PREPEND_NAMESPACE(qfloat16)>
|
|
: public numeric_limits<QT_PREPEND_NAMESPACE(qfloat16)> {};
|
|
template<> class numeric_limits<volatile QT_PREPEND_NAMESPACE(qfloat16)>
|
|
: public numeric_limits<QT_PREPEND_NAMESPACE(qfloat16)> {};
|
|
template<> class numeric_limits<const volatile QT_PREPEND_NAMESPACE(qfloat16)>
|
|
: public numeric_limits<QT_PREPEND_NAMESPACE(qfloat16)> {};
|
|
|
|
// Adding overloads to std isn't allowed, so we can't extend this to support
|
|
// for fpclassify(), isnormal() &c. (which, furthermore, are macros on MinGW).
|
|
} // namespace std
|
|
|
|
#endif // QFLOAT16_H
|