1 | /**************************************************************************** |
---|---|

2 | ** |

3 | ** Copyright (C) 2016 The Qt Company Ltd. |

4 | ** Contact: https://www.qt.io/licensing/ |

5 | ** |

6 | ** This file is part of the QtCore module of the Qt Toolkit. |

7 | ** |

8 | ** $QT_BEGIN_LICENSE:LGPL$ |

9 | ** Commercial License Usage |

10 | ** Licensees holding valid commercial Qt licenses may use this file in |

11 | ** accordance with the commercial license agreement provided with the |

12 | ** Software or, alternatively, in accordance with the terms contained in |

13 | ** a written agreement between you and The Qt Company. For licensing terms |

14 | ** and conditions see https://www.qt.io/terms-conditions. For further |

15 | ** information use the contact form at https://www.qt.io/contact-us. |

16 | ** |

17 | ** GNU Lesser General Public License Usage |

18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |

19 | ** General Public License version 3 as published by the Free Software |

20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |

21 | ** packaging of this file. Please review the following information to |

22 | ** ensure the GNU Lesser General Public License version 3 requirements |

23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |

24 | ** |

25 | ** GNU General Public License Usage |

26 | ** Alternatively, this file may be used under the terms of the GNU |

27 | ** General Public License version 2.0 or (at your option) the GNU General |

28 | ** Public license version 3 or any later version approved by the KDE Free |

29 | ** Qt Foundation. The licenses are as published by the Free Software |

30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |

31 | ** included in the packaging of this file. Please review the following |

32 | ** information to ensure the GNU General Public License requirements will |

33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |

34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |

35 | ** |

36 | ** $QT_END_LICENSE$ |

37 | ** |

38 | ****************************************************************************/ |

39 | |

40 | #ifndef QMATH_H |

41 | #define QMATH_H |

42 | |

43 | #if 0 |

44 | #pragma qt_class(QtMath) |

45 | #endif |

46 | |

47 | #include <QtCore/qglobal.h> |

48 | #include <QtCore/qalgorithms.h> |

49 | |

50 | #ifndef _USE_MATH_DEFINES |

51 | # define _USE_MATH_DEFINES |

52 | # define undef_USE_MATH_DEFINES |

53 | #endif |

54 | |

55 | #include <cmath> |

56 | |

57 | #ifdef undef_USE_MATH_DEFINES |

58 | # undef _USE_MATH_DEFINES |

59 | # undef undef_USE_MATH_DEFINES |

60 | #endif |

61 | |

62 | QT_BEGIN_NAMESPACE |

63 | |

64 | #define QT_SINE_TABLE_SIZE 256 |

65 | |

66 | extern Q_CORE_EXPORT const qreal qt_sine_table[QT_SINE_TABLE_SIZE]; |

67 | |

68 | inline int qCeil(qreal v) |

69 | { |

70 | using std::ceil; |

71 | return int(ceil(v)); |

72 | } |

73 | |

74 | inline int qFloor(qreal v) |

75 | { |

76 | using std::floor; |

77 | return int(floor(v)); |

78 | } |

79 | |

80 | inline qreal qFabs(qreal v) |

81 | { |

82 | using std::fabs; |

83 | return fabs(v); |

84 | } |

85 | |

86 | inline qreal qSin(qreal v) |

87 | { |

88 | using std::sin; |

89 | return sin(v); |

90 | } |

91 | |

92 | inline qreal qCos(qreal v) |

93 | { |

94 | using std::cos; |

95 | return cos(v); |

96 | } |

97 | |

98 | inline qreal qTan(qreal v) |

99 | { |

100 | using std::tan; |

101 | return tan(v); |

102 | } |

103 | |

104 | inline qreal qAcos(qreal v) |

105 | { |

106 | using std::acos; |

107 | return acos(v); |

108 | } |

109 | |

110 | inline qreal qAsin(qreal v) |

111 | { |

112 | using std::asin; |

113 | return asin(v); |

114 | } |

115 | |

116 | inline qreal qAtan(qreal v) |

117 | { |

118 | using std::atan; |

119 | return atan(v); |

120 | } |

121 | |

122 | inline qreal qAtan2(qreal y, qreal x) |

123 | { |

124 | using std::atan2; |

125 | return atan2(y, x); |

126 | } |

127 | |

128 | inline qreal qSqrt(qreal v) |

129 | { |

130 | using std::sqrt; |

131 | return sqrt(v); |

132 | } |

133 | |

134 | inline qreal qLn(qreal v) |

135 | { |

136 | using std::log; |

137 | return log(v); |

138 | } |

139 | |

140 | inline qreal qExp(qreal v) |

141 | { |

142 | using std::exp; |

143 | return exp(v); |

144 | } |

145 | |

146 | inline qreal qPow(qreal x, qreal y) |

147 | { |

148 | using std::pow; |

149 | return pow(x, y); |

150 | } |

151 | |

152 | // TODO: use template variables (e.g. Qt::pi<type>) for these once we have C++14 support: |

153 | |

154 | #ifndef M_E |

155 | #define M_E (2.7182818284590452354) |

156 | #endif |

157 | |

158 | #ifndef M_LOG2E |

159 | #define M_LOG2E (1.4426950408889634074) |

160 | #endif |

161 | |

162 | #ifndef M_LOG10E |

163 | #define M_LOG10E (0.43429448190325182765) |

164 | #endif |

165 | |

166 | #ifndef M_LN2 |

167 | #define M_LN2 (0.69314718055994530942) |

168 | #endif |

169 | |

170 | #ifndef M_LN10 |

171 | #define M_LN10 (2.30258509299404568402) |

172 | #endif |

173 | |

174 | #ifndef M_PI |

175 | #define M_PI (3.14159265358979323846) |

176 | #endif |

177 | |

178 | #ifndef M_PI_2 |

179 | #define M_PI_2 (1.57079632679489661923) |

180 | #endif |

181 | |

182 | #ifndef M_PI_4 |

183 | #define M_PI_4 (0.78539816339744830962) |

184 | #endif |

185 | |

186 | #ifndef M_1_PI |

187 | #define M_1_PI (0.31830988618379067154) |

188 | #endif |

189 | |

190 | #ifndef M_2_PI |

191 | #define M_2_PI (0.63661977236758134308) |

192 | #endif |

193 | |

194 | #ifndef M_2_SQRTPI |

195 | #define M_2_SQRTPI (1.12837916709551257390) |

196 | #endif |

197 | |

198 | #ifndef M_SQRT2 |

199 | #define M_SQRT2 (1.41421356237309504880) |

200 | #endif |

201 | |

202 | #ifndef M_SQRT1_2 |

203 | #define M_SQRT1_2 (0.70710678118654752440) |

204 | #endif |

205 | |

206 | inline qreal qFastSin(qreal x) |

207 | { |

208 | int si = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower. |

209 | qreal d = x - si * (2.0 * M_PI / QT_SINE_TABLE_SIZE); |

210 | int ci = si + QT_SINE_TABLE_SIZE / 4; |

211 | si &= QT_SINE_TABLE_SIZE - 1; |

212 | ci &= QT_SINE_TABLE_SIZE - 1; |

213 | return qt_sine_table[si] + (qt_sine_table[ci] - 0.5 * qt_sine_table[si] * d) * d; |

214 | } |

215 | |

216 | inline qreal qFastCos(qreal x) |

217 | { |

218 | int ci = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower. |

219 | qreal d = x - ci * (2.0 * M_PI / QT_SINE_TABLE_SIZE); |

220 | int si = ci + QT_SINE_TABLE_SIZE / 4; |

221 | si &= QT_SINE_TABLE_SIZE - 1; |

222 | ci &= QT_SINE_TABLE_SIZE - 1; |

223 | return qt_sine_table[si] - (qt_sine_table[ci] + 0.5 * qt_sine_table[si] * d) * d; |

224 | } |

225 | |

226 | Q_DECL_CONSTEXPR inline float qDegreesToRadians(float degrees) |

227 | { |

228 | return degrees * float(M_PI/180); |

229 | } |

230 | |

231 | Q_DECL_CONSTEXPR inline double qDegreesToRadians(double degrees) |

232 | { |

233 | return degrees * (M_PI / 180); |

234 | } |

235 | |

236 | Q_DECL_CONSTEXPR inline float qRadiansToDegrees(float radians) |

237 | { |

238 | return radians * float(180/M_PI); |

239 | } |

240 | |

241 | Q_DECL_CONSTEXPR inline double qRadiansToDegrees(double radians) |

242 | { |

243 | return radians * (180 / M_PI); |

244 | } |

245 | |

246 | |

247 | Q_DECL_RELAXED_CONSTEXPR inline quint32 qNextPowerOfTwo(quint32 v) |

248 | { |

249 | #if defined(QT_HAS_BUILTIN_CLZ) |

250 | if (v == 0) |

251 | return 1; |

252 | return 2U << (31 ^ QAlgorithmsPrivate::qt_builtin_clz(v)); |

253 | #else |

254 | v |= v >> 1; |

255 | v |= v >> 2; |

256 | v |= v >> 4; |

257 | v |= v >> 8; |

258 | v |= v >> 16; |

259 | ++v; |

260 | return v; |

261 | #endif |

262 | } |

263 | |

264 | Q_DECL_RELAXED_CONSTEXPR inline quint64 qNextPowerOfTwo(quint64 v) |

265 | { |

266 | #if defined(QT_HAS_BUILTIN_CLZLL) |

267 | if (v == 0) |

268 | return 1; |

269 | return Q_UINT64_C(2) << (63 ^ QAlgorithmsPrivate::qt_builtin_clzll(v)); |

270 | #else |

271 | v |= v >> 1; |

272 | v |= v >> 2; |

273 | v |= v >> 4; |

274 | v |= v >> 8; |

275 | v |= v >> 16; |

276 | v |= v >> 32; |

277 | ++v; |

278 | return v; |

279 | #endif |

280 | } |

281 | |

282 | Q_DECL_RELAXED_CONSTEXPR inline quint32 qNextPowerOfTwo(qint32 v) |

283 | { |

284 | return qNextPowerOfTwo(quint32(v)); |

285 | } |

286 | |

287 | Q_DECL_RELAXED_CONSTEXPR inline quint64 qNextPowerOfTwo(qint64 v) |

288 | { |

289 | return qNextPowerOfTwo(quint64(v)); |

290 | } |

291 | |

292 | QT_END_NAMESPACE |

293 | |

294 | #endif // QMATH_H |

295 |