1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://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 http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://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 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file. Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #ifndef QMATH_H
43 #define QMATH_H
44
45 #include <math.h>
46
47 #include <QtCore/qglobal.h>
48
49 #ifdef Q_OS_SYMBIAN
50 # include <e32math.h>
51 #endif
52
53 QT_BEGIN_HEADER
54
55 QT_BEGIN_NAMESPACE
56
57 QT_MODULE(Core)
58
59 #define QT_SINE_TABLE_SIZE 256
60
61 extern Q_CORE_EXPORT const qreal qt_sine_table[QT_SINE_TABLE_SIZE];
62
qCeil(qreal v)63 inline int qCeil(qreal v)
64 {
65 #ifdef QT_USE_MATH_H_FLOATS
66 if (sizeof(qreal) == sizeof(float))
67 return int(ceilf(float(v)));
68 else
69 #endif
70 return int(ceil(v));
71 }
72
qFloor(qreal v)73 inline int qFloor(qreal v)
74 {
75 #ifdef QT_USE_MATH_H_FLOATS
76 if (sizeof(qreal) == sizeof(float))
77 return int(floorf(float(v)));
78 else
79 #endif
80 return int(floor(v));
81 }
82
qFabs(qreal v)83 inline qreal qFabs(qreal v)
84 {
85 #ifdef QT_USE_MATH_H_FLOATS
86 if(sizeof(qreal) == sizeof(float))
87 return fabsf(float(v));
88 else
89 #endif
90 return fabs(v);
91 }
92
qSin(qreal v)93 inline qreal qSin(qreal v)
94 {
95 #ifdef Q_OS_SYMBIAN
96 TReal sin_v;
97 Math::Sin(sin_v, static_cast<TReal>(v));
98 return static_cast<qreal>(sin_v);
99 #else
100 # ifdef QT_USE_MATH_H_FLOATS
101 if (sizeof(qreal) == sizeof(float))
102 return sinf(float(v));
103 else
104 # endif
105 return sin(v);
106 #endif
107 }
108
qCos(qreal v)109 inline qreal qCos(qreal v)
110 {
111 #ifdef Q_OS_SYMBIAN
112 TReal cos_v;
113 Math::Cos(cos_v, static_cast<TReal>(v));
114 return static_cast<qreal>(cos_v);
115 #else
116 # ifdef QT_USE_MATH_H_FLOATS
117 if (sizeof(qreal) == sizeof(float))
118 return cosf(float(v));
119 else
120 # endif
121 return cos(v);
122 #endif
123 }
124
qTan(qreal v)125 inline qreal qTan(qreal v)
126 {
127 #ifdef Q_OS_SYMBIAN
128 TReal tan_v;
129 Math::Tan(tan_v, static_cast<TReal>(v));
130 return static_cast<qreal>(tan_v);
131 #else
132 # ifdef QT_USE_MATH_H_FLOATS
133 if (sizeof(qreal) == sizeof(float))
134 return tanf(float(v));
135 else
136 # endif
137 return tan(v);
138 #endif
139 }
140
qAcos(qreal v)141 inline qreal qAcos(qreal v)
142 {
143 #ifdef Q_OS_SYMBIAN
144 TReal acos_v;
145 Math::ACos(acos_v, static_cast<TReal>(v));
146 return static_cast<qreal>(acos_v);
147 #else
148 # ifdef QT_USE_MATH_H_FLOATS
149 if (sizeof(qreal) == sizeof(float))
150 return acosf(float(v));
151 else
152 # endif
153 return acos(v);
154 #endif
155 }
156
qAsin(qreal v)157 inline qreal qAsin(qreal v)
158 {
159 #ifdef Q_OS_SYMBIAN
160 TReal asin_v;
161 Math::ASin(asin_v, static_cast<TReal>(v));
162 return static_cast<qreal>(asin_v);
163 #else
164 # ifdef QT_USE_MATH_H_FLOATS
165 if (sizeof(qreal) == sizeof(float))
166 return asinf(float(v));
167 else
168 # endif
169 return asin(v);
170 #endif
171 }
172
qAtan(qreal v)173 inline qreal qAtan(qreal v)
174 {
175 #ifdef Q_OS_SYMBIAN
176 TReal atan_v;
177 Math::ATan(atan_v, static_cast<TReal>(v));
178 return static_cast<qreal>(atan_v);
179 #else
180 # ifdef QT_USE_MATH_H_FLOATS
181 if(sizeof(qreal) == sizeof(float))
182 return atanf(float(v));
183 else
184 # endif
185 return atan(v);
186 #endif
187 }
188
qAtan2(qreal x,qreal y)189 inline qreal qAtan2(qreal x, qreal y)
190 {
191 #ifdef Q_OS_SYMBIAN
192 TReal atan2_v;
193 Math::ATan(atan2_v, static_cast<TReal>(x), static_cast<TReal>(y));
194 return static_cast<qreal>(atan2_v);
195 #else
196 # ifdef QT_USE_MATH_H_FLOATS
197 if(sizeof(qreal) == sizeof(float))
198 return atan2f(float(x), float(y));
199 else
200 # endif
201 return atan2(x, y);
202 #endif
203 }
204
qSqrt(qreal v)205 inline qreal qSqrt(qreal v)
206 {
207 #ifdef Q_OS_SYMBIAN
208 TReal sqrt_v;
209 Math::Sqrt(sqrt_v, static_cast<TReal>(v));
210 return static_cast<qreal>(sqrt_v);
211 #else
212 # ifdef QT_USE_MATH_H_FLOATS
213 if (sizeof(qreal) == sizeof(float))
214 return sqrtf(float(v));
215 else
216 # endif
217 return sqrt(v);
218 #endif
219 }
220
qLn(qreal v)221 inline qreal qLn(qreal v)
222 {
223 #ifdef QT_USE_MATH_H_FLOATS
224 if (sizeof(qreal) == sizeof(float))
225 return logf(float(v));
226 else
227 #endif
228 return log(v);
229 }
230
qExp(qreal v)231 inline qreal qExp(qreal v)
232 {
233 #ifdef Q_OS_SYMBIAN
234 TReal exp_v;
235 Math::Exp(exp_v, static_cast<TReal>(v));
236 return static_cast<qreal>(exp_v);
237 #else
238 // only one signature
239 // exists, exp(double)
240 return exp(v);
241 #endif
242 }
243
qPow(qreal x,qreal y)244 inline qreal qPow(qreal x, qreal y)
245 {
246 #ifdef Q_OS_SYMBIAN
247 TReal pow_v;
248 Math::Pow(pow_v, static_cast<TReal>(x), static_cast<TReal>(y));
249 return static_cast<qreal>(pow_v);
250 #else
251 # ifdef QT_USE_MATH_H_FLOATS
252 if (sizeof(qreal) == sizeof(float))
253 return powf(float(x), float(y));
254 else
255 # endif
256 return pow(x, y);
257 #endif
258 }
259
260 #ifndef M_PI
261 #define M_PI (3.14159265358979323846)
262 #endif
263
qFastSin(qreal x)264 inline qreal qFastSin(qreal x)
265 {
266 int si = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower.
267 qreal d = x - si * (2.0 * M_PI / QT_SINE_TABLE_SIZE);
268 int ci = si + QT_SINE_TABLE_SIZE / 4;
269 si &= QT_SINE_TABLE_SIZE - 1;
270 ci &= QT_SINE_TABLE_SIZE - 1;
271 return qt_sine_table[si] + (qt_sine_table[ci] - 0.5 * qt_sine_table[si] * d) * d;
272 }
273
qFastCos(qreal x)274 inline qreal qFastCos(qreal x)
275 {
276 int ci = int(x * (0.5 * QT_SINE_TABLE_SIZE / M_PI)); // Would be more accurate with qRound, but slower.
277 qreal d = x - ci * (2.0 * M_PI / QT_SINE_TABLE_SIZE);
278 int si = ci + QT_SINE_TABLE_SIZE / 4;
279 si &= QT_SINE_TABLE_SIZE - 1;
280 ci &= QT_SINE_TABLE_SIZE - 1;
281 return qt_sine_table[si] - (qt_sine_table[ci] + 0.5 * qt_sine_table[si] * d) * d;
282 }
283
284 QT_END_NAMESPACE
285
286 QT_END_HEADER
287
288 #endif // QMATH_H
289