Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #ifndef QMATH_H
++ #define QMATH_H
++
++ #if 0
++ #pragma qt_class(QtMath)
++ #endif
++
++ #include <QtCore/qglobal.h>
++ #include <QtCore/qalgorithms.h>
++ #include <QtCore/qnumeric.h>
++
++ #if __has_include(<bit>) && __cplusplus > 201703L
++ #include <bit>
++ #endif
++
++ #include <cmath>
++
++ QT_BEGIN_NAMESPACE
++
++ #define QT_SINE_TABLE_SIZE 256
++
++ extern Q_CORE_EXPORT const qreal qt_sine_table[QT_SINE_TABLE_SIZE];
++
++ template <typename T> int qCeil(T v)
++ {
++ using std::ceil;
++ return QtPrivate::qCheckedFPConversionToInteger<int>(ceil(v));
++ }
++
++ template <typename T> int qFloor(T v)
++ {
++ using std::floor;
++ return QtPrivate::qCheckedFPConversionToInteger<int>(floor(v));
++ }
++
++ template <typename T> auto qFabs(T v)
++ {
++ using std::fabs;
++ return fabs(v);
++ }
++
++ template <typename T> auto qSin(T v)
++ {
++ using std::sin;
++ return sin(v);
++ }
++
++ template <typename T> auto qCos(T v)
++ {
++ using std::cos;
++ return cos(v);
++ }
++
++ template <typename T> auto qTan(T v)
++ {
++ using std::tan;
++ return tan(v);
++ }
++
++ template <typename T> auto qAcos(T v)
++ {
++ using std::acos;
++ return acos(v);
++ }
++
++ template <typename T> auto qAsin(T v)
++ {
++ using std::asin;
++ return asin(v);
++ }
++
++ template <typename T> auto qAtan(T v)
++ {
++ using std::atan;
++ return atan(v);
++ }
++
++ template <typename T1, typename T2> auto qAtan2(T1 y, T2 x)
++ {
++ using std::atan2;
++ return atan2(y, x);
++ }
++
++ template <typename T> auto qSqrt(T v)
++ {
++ using std::sqrt;
++ return sqrt(v);
++ }
++
++ namespace QtPrivate {
++ template <typename R, typename F> // For qfloat16 to specialize
++ struct QHypotType { using type = decltype(std::hypot(R(1), F(1))); };
++
++ // Implements hypot() without limiting number of arguments:
++ template <typename T>
++ class QHypotHelper
++ {
++ T scale, total;
++ template <typename F> friend class QHypotHelper;
++ QHypotHelper(T first, T prior) : scale(first), total(prior) {}
++ public:
++ QHypotHelper(T first) : scale(qAbs(first)), total(1) {}
++ T result() const
++ { return qIsFinite(scale) ? scale > 0 ? scale * T(qSqrt(total)) : T(0) : scale; }
++
++ template<typename F, typename ...Fs>
++ auto add(F first, Fs... rest) const
++ { return add(first).add(rest...); }
++
++ template<typename F, typename R = typename QHypotType<T, F>::type>
++ QHypotHelper<R> add(F next) const
++ {
++ if (qIsInf(scale) || (qIsNaN(scale) && !qIsInf(next)))
++ return QHypotHelper<R>(scale, R(1));
++ if (qIsNaN(next))
++ return QHypotHelper<R>(next, R(1));
++ const R val = qAbs(next);
++ if (!(scale > 0) || qIsInf(next))
++ return QHypotHelper<R>(val, R(1));
++ if (!(val > 0))
++ return QHypotHelper<R>(scale, total);
++ if (val > scale) {
++ const R ratio = scale / next;
++ return QHypotHelper<R>(val, total * ratio * ratio + R(1));
++ }
++ const R ratio = next / scale;
++ return QHypotHelper<R>(scale, total + ratio * ratio);
++ }
++ };
++ } // QtPrivate
++
++ template<typename F, typename ...Fs>
++ auto qHypot(F first, Fs... rest)
++ {
++ return QtPrivate::QHypotHelper<F>(first).add(rest...).result();
++ }
++
++ // However, where possible, use the standard library implementations:
++ template <typename Tx, typename Ty>
++ auto qHypot(Tx x, Ty y)
++ {
++ // C99 has hypot(), hence C++11 has std::hypot()
++ using std::hypot;
++ return hypot(x, y);
++ }
++
++ #if defined(__cpp_lib_hypot) && __cpp_lib_hypot >= 201603L // Expected to be true
++ template <typename Tx, typename Ty, typename Tz>
++ auto qHypot(Tx x, Ty y, Tz z)
++ {
++ using std::hypot;
++ return hypot(x, y, z);
++ }
++ #endif // else: no need to over-ride the arbitrarily-many-arg form
++
++ template <typename T> auto qLn(T v)
++ {
++ using std::log;
++ return log(v);
++ }
++
++ template <typename T> auto qExp(T v)
++ {
++ using std::exp;
++ return exp(v);
++ }
++
++ template <typename T1, typename T2> auto qPow(T1 x, T2 y)
++ {
++ using std::pow;
++ return pow(x, y);
++ }
++
++ // TODO: use template variables (e.g. Qt::pi<type>) for these once we have C++14 support:
++
++ #ifndef M_E
++ #define M_E (2.7182818284590452354)
++ #endif
++
++ #ifndef M_LOG2E
++ #define M_LOG2E (1.4426950408889634074)
++ #endif
++
++ #ifndef M_LOG10E
++ #define M_LOG10E (0.43429448190325182765)
++ #endif
++
++ #ifndef M_LN2
++ #define M_LN2 (0.69314718055994530942)
++ #endif
++
++ #ifndef M_LN10
++ #define M_LN10 (2.30258509299404568402)
++ #endif
++
++ #ifndef M_PI
++ #define M_PI (3.14159265358979323846)
++ #endif
++
++ #ifndef M_PI_2
++ #define M_PI_2 (1.57079632679489661923)
++ #endif
++
++ #ifndef M_PI_4
++ #define M_PI_4 (0.78539816339744830962)
++ #endif
++
++ #ifndef M_1_PI
++ #define M_1_PI (0.31830988618379067154)
++ #endif
++
++ #ifndef M_2_PI
++ #define M_2_PI (0.63661977236758134308)
++ #endif
++
++ #ifndef M_2_SQRTPI
++ #define M_2_SQRTPI (1.12837916709551257390)
++ #endif
++
++ #ifndef M_SQRT2
++ #define M_SQRT2 (1.41421356237309504880)
++ #endif
++
++ #ifndef M_SQRT1_2
++ #define M_SQRT1_2 (0.70710678118654752440)
++ #endif
++
++ inline qreal qFastSin(qreal x)
++ {
++ int si = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower.
++ qreal d = x - si * (2.0 * M_PI / QT_SINE_TABLE_SIZE);
++ int ci = si + QT_SINE_TABLE_SIZE / 4;
++ si &= QT_SINE_TABLE_SIZE - 1;
++ ci &= QT_SINE_TABLE_SIZE - 1;
++ return qt_sine_table[si] + (qt_sine_table[ci] - 0.5 * qt_sine_table[si] * d) * d;
++ }
++
++ inline qreal qFastCos(qreal x)
++ {
++ int ci = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower.
++ qreal d = x - ci * (2.0 * M_PI / QT_SINE_TABLE_SIZE);
++ int si = ci + QT_SINE_TABLE_SIZE / 4;
++ si &= QT_SINE_TABLE_SIZE - 1;
++ ci &= QT_SINE_TABLE_SIZE - 1;
++ return qt_sine_table[si] - (qt_sine_table[ci] + 0.5 * qt_sine_table[si] * d) * d;
++ }
++
++ constexpr inline float qDegreesToRadians(float degrees)
++ {
++ return degrees * float(M_PI / 180);
++ }
++
++ constexpr inline double qDegreesToRadians(double degrees)
++ {
++ return degrees * (M_PI / 180);
++ }
++
++ constexpr inline long double qDegreesToRadians(long double degrees)
++ {
++ return degrees * (M_PI / 180);
++ }
++
++ template <typename T, std::enable_if_t<std::is_integral_v<T>, bool> = true>
++ constexpr inline double qDegreesToRadians(T degrees)
++ {
++ return qDegreesToRadians(static_cast<double>(degrees));
++ }
++
++ constexpr inline float qRadiansToDegrees(float radians)
++ {
++ return radians * float(180 / M_PI);
++ }
++
++ constexpr inline double qRadiansToDegrees(double radians)
++ {
++ return radians * (180 / M_PI);
++ }
++
++ constexpr inline long double qRadiansToDegrees(long double radians)
++ {
++ return radians * (180 / M_PI);
++ }
++
++ // A qRadiansToDegrees(Integral) overload isn't here; it's extremely
++ // questionable that someone is manipulating quantities in radians
++ // using integral datatypes...
++
++ constexpr inline quint32 qNextPowerOfTwo(quint32 v)
++ {
++ Q_ASSERT(static_cast<qint32>(v) >= 0); // There is a next power of two
++ return q20::bit_ceil(v + 1);
++ }
++
++ constexpr inline quint64 qNextPowerOfTwo(quint64 v)
++ {
++ Q_ASSERT(static_cast<qint64>(v) >= 0); // There is a next power of two
++ return q20::bit_ceil(v + 1);
++ }
++
++ constexpr inline quint32 qNextPowerOfTwo(qint32 v)
++ {
++ return qNextPowerOfTwo(quint32(v));
++ }
++
++ constexpr inline quint64 qNextPowerOfTwo(qint64 v)
++ {
++ return qNextPowerOfTwo(quint64(v));
++ }
++
++ constexpr inline unsigned long qNextPowerOfTwo(unsigned long v)
++ {
++ return qNextPowerOfTwo(QIntegerForSizeof<long>::Unsigned(v));
++ }
++
++ constexpr inline unsigned long qNextPowerOfTwo(long v)
++ {
++ return qNextPowerOfTwo(QIntegerForSizeof<long>::Unsigned(v));
++ }
++
++ QT_END_NAMESPACE
++
++ #endif // QMATH_H