Using qreal more consistently in code (prevent misuse of double)

We want to force use of qreal where possible. This can lead to better
performance on platforms where qreal -> float (i.e. ARM). To achieve
this we:

1. changed from 'double' to 'qreal', where justified
2. using qreal() to intialize constants, where justified
3. adding helper functions that are overloaded for qreal
   like qAtan2(), qAcos(), qFabs() ...
4. defining QT_USE_MATH_H_FLOATS for Symbian platform

In addtion we used opportunity to improve code with some small things
5. converting divisions to multiplications
   (i.e. '/ 2.0' -> '* qreal(0.5)')
6. defining new constants (i.e. 'Q_PI / 180.0' -> 'Q_PI180')
7. declaring variables as 'const', where justified

Reviewed-by: Andreas Aardal Hanssen
Reviewed-by: Gunnar Sletta
Reviewed-by: Jan-Arve
Reviewed-by: Kim Motoyoshi Kalland
Reviewed-by: Alessandro Portale
Reviewed-by: Janne Koskinen

55 files changed, 788 insertions, 705 deletions

diff --git a/src/3rdparty/easing/easing.cpp b/src/3rdparty/easing/easing.cpp
index 81af40f..65e9f95 100644
--- a/src/3rdparty/easing/easing.cpp
+++ b/src/3rdparty/easing/easing.cpp
@@ -18,13 +18,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 */
 
 #include <QtCore/qmath.h>
-#include <math.h>
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-#ifndef M_PI_2
-#define M_PI_2 (M_PI / 2)
-#endif
+#include <private/qnumeric_p.h>
 
 QT_USE_NAMESPACE
 
@@ -69,12 +63,12 @@ static qreal easeOutQuad(qreal t)
  */
 static qreal easeInOutQuad(qreal t)
 {
-    t*=2.0;
+    t*=qreal(2.0);
     if (t < 1) {
-        return t*t/qreal(2);
+        return t*t*qreal(0.5);
     } else {
         --t;
-        return -0.5 * (t*(t-2) - 1);
+        return qreal(-0.5) * (t*(t-2) - 1);
     }
 }
 
@@ -86,8 +80,8 @@ static qreal easeInOutQuad(qreal t)
  */
 static qreal easeOutInQuad(qreal t)
 {
-    if (t < 0.5) return easeOutQuad (t*2)/2;
-    return easeInQuad((2*t)-1)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutQuad (t*2) * qreal(0.5);
+    return easeInQuad((2*t)-1) * qreal(0.5) + qreal(0.5);
 }
 
 /**
@@ -109,7 +103,7 @@ static qreal easeInCubic(qreal t)
  */
 static qreal easeOutCubic(qreal t)
 {
-    t-=1.0;
+    t-=qreal(1.0);
     return t*t*t + 1;
 }
 
@@ -121,12 +115,12 @@ static qreal easeOutCubic(qreal t)
  */
 static qreal easeInOutCubic(qreal t)
 {
-    t*=2.0;
+    t*=qreal(2.0);
     if(t < 1) {
-        return 0.5*t*t*t;
+        return qreal(0.5)*t*t*t;
     } else {
         t -= qreal(2.0);
-        return 0.5*(t*t*t + 2);
+        return qreal(0.5)*(t*t*t + 2);
     }
 }
 
@@ -138,8 +132,8 @@ static qreal easeInOutCubic(qreal t)
  */
 static qreal easeOutInCubic(qreal t)
 {
-    if (t < 0.5) return easeOutCubic (2*t)/2;
-    return easeInCubic(2*t - 1)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutCubic (2*t) * qreal(0.5);
+    return easeInCubic(2*t - 1) * qreal(0.5) + qreal(0.5);
 }
 
 /**
@@ -174,10 +168,10 @@ static qreal easeOutQuart(qreal t)
 static qreal easeInOutQuart(qreal t)
 {
     t*=2;
-    if (t < 1) return 0.5*t*t*t*t;
+    if (t < 1) return qreal(0.5)*t*t*t*t;
     else {
         t -= 2.0f;
-        return -0.5 * (t*t*t*t- 2);
+        return qreal(-0.5) * (t*t*t*t- 2);
     }
 }
 
@@ -189,8 +183,8 @@ static qreal easeInOutQuart(qreal t)
  */
 static qreal easeOutInQuart(qreal t)
 {
-    if (t < 0.5) return easeOutQuart (2*t)/2;
-    return easeInQuart(2*t-1)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutQuart (2*t) * qreal(0.5);
+    return easeInQuart(2*t-1) * qreal(0.5) + qreal(0.5);
 }
 
 /**
@@ -212,7 +206,7 @@ static qreal easeInQuint(qreal t)
  */
 static qreal easeOutQuint(qreal t)
 {
-    t-=1.0;
+    t-=qreal(1.0);
     return t*t*t*t*t + 1;
 }
 
@@ -224,11 +218,11 @@ static qreal easeOutQuint(qreal t)
  */
 static qreal easeInOutQuint(qreal t)
 {
-    t*=2.0;
-    if (t < 1) return 0.5*t*t*t*t*t;
+    t*=qreal(2.0);
+    if (t < 1) return qreal(0.5)*t*t*t*t*t;
     else {
-        t -= 2.0;
-        return 0.5*(t*t*t*t*t + 2);
+        t -= qreal(2.0);
+        return qreal(0.5)*(t*t*t*t*t + 2);
     }
 }
 
@@ -240,8 +234,8 @@ static qreal easeInOutQuint(qreal t)
  */
 static qreal easeOutInQuint(qreal t)
 {
-    if (t < 0.5) return easeOutQuint (2*t)/2;
-    return easeInQuint(2*t - 1)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutQuint (2*t) * qreal(0.5);
+    return easeInQuint(2*t - 1) * qreal(0.5) + qreal(0.5);
 }
 
 /**
@@ -252,7 +246,7 @@ static qreal easeOutInQuint(qreal t)
  */
 static qreal easeInSine(qreal t)
 {
-    return (t == 1.0) ? 1.0 : -::cos(t * M_PI_2) + 1.0;
+    return (t == qreal(1.0)) ? qreal(1.0) : -qCos(t * Q_PI2) + qreal(1.0);
 }
 
 /**
@@ -263,7 +257,7 @@ static qreal easeInSine(qreal t)
  */
 static qreal easeOutSine(qreal t)
 {
-    return ::sin(t* M_PI_2);
+    return qSin(t* Q_PI2);
 }
 
 /**
@@ -274,7 +268,7 @@ static qreal easeOutSine(qreal t)
  */
 static qreal easeInOutSine(qreal t)
 {
-    return -0.5 * (::cos(M_PI*t) - 1);
+    return qreal(-0.5) * (qCos(Q_PI*t) - 1);
 }
 
 /**
@@ -285,8 +279,8 @@ static qreal easeInOutSine(qreal t)
  */
 static qreal easeOutInSine(qreal t)
 {
-    if (t < 0.5) return easeOutSine (2*t)/2;
-    return easeInSine(2*t - 1)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutSine (2*t) * qreal(0.5);
+    return easeInSine(2*t - 1) * qreal(0.5) + qreal(0.5);
 }
 
 /**
@@ -297,7 +291,7 @@ static qreal easeOutInSine(qreal t)
  */
 static qreal easeInExpo(qreal t)
 {
-    return (t==0 || t == 1.0) ? t : ::qPow(2.0, 10 * (t - 1)) - qreal(0.001);
+    return (t==0 || t == qreal(1.0)) ? t : ::qPow(qreal(2.0), 10 * (t - 1)) - qreal(0.001);
 }
 
 /**
@@ -308,7 +302,7 @@ static qreal easeInExpo(qreal t)
  */
 static qreal easeOutExpo(qreal t)
 {
-    return (t==1.0) ? 1.0 : 1.001 * (-::qPow(2.0f, -10 * t) + 1);
+    return (t==qreal(1.0)) ? qreal(1.0) : qreal(1.001) * (-::qPow(2.0f, -10 * t) + 1);
 }
 
 /**
@@ -319,11 +313,11 @@ static qreal easeOutExpo(qreal t)
  */
 static qreal easeInOutExpo(qreal t)
 {
-    if (t==0.0) return qreal(0.0);
-    if (t==1.0) return qreal(1.0);
-    t*=2.0;
-    if (t < 1) return 0.5 * ::qPow(qreal(2.0), 10 * (t - 1)) - 0.0005;
-    return 0.5 * 1.0005 * (-::qPow(qreal(2.0), -10 * (t - 1)) + 2);
+    if (t==qreal(0.0)) return qreal(0.0);
+    if (t==qreal(1.0)) return qreal(1.0);
+    t*=qreal(2.0);
+    if (t < 1) return qreal(0.5) * ::qPow(qreal(2.0), 10 * (t - 1)) - qreal(0.0005);
+    return qreal(0.5) * qreal(1.0005) * (-::qPow(qreal(2.0), -10 * (t - 1)) + 2);
 }
 
 /**
@@ -334,8 +328,8 @@ static qreal easeInOutExpo(qreal t)
  */
 static qreal easeOutInExpo(qreal t)
 {
-    if (t < 0.5) return easeOutExpo (2*t)/2;
-    return easeInExpo(2*t - 1)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutExpo (2*t) * qreal(0.5);
+    return easeInExpo(2*t - 1) * qreal(0.5) + qreal(0.5);
 }
 
 /**
@@ -346,7 +340,7 @@ static qreal easeOutInExpo(qreal t)
  */
 static qreal easeInCirc(qreal t)
 {
-    return -(::sqrt(1 - t*t) - 1);
+    return -(::qSqrt(1 - t*t) - 1);
 }
 
 /**
@@ -358,7 +352,7 @@ static qreal easeInCirc(qreal t)
 static qreal easeOutCirc(qreal t)
 {
     t-= qreal(1.0);
-    return ::sqrt(1 - t* t);
+    return ::qSqrt(1 - t* t);
 }
 
 /**
@@ -371,10 +365,10 @@ static qreal easeInOutCirc(qreal t)
 {
     t*=qreal(2.0);
     if (t < 1) {
-        return -0.5 * (::sqrt(1 - t*t) - 1);
+        return qreal(-0.5) * (::qSqrt(1 - t*t) - 1);
     } else {
         t -= qreal(2.0);
-        return 0.5 * (::sqrt(1 - t*t) + 1);
+        return qreal(0.5) * (::qSqrt(1 - t*t) + 1);
     }
 }
 
@@ -386,26 +380,26 @@ static qreal easeInOutCirc(qreal t)
  */
 static qreal easeOutInCirc(qreal t)
 {
-    if (t < 0.5) return easeOutCirc (2*t)/2;
-    return easeInCirc(2*t - 1)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutCirc (2*t)*qreal(0.5);
+    return easeInCirc(2*t - 1)*qreal(0.5) + qreal(0.5);
 }
 
 static qreal easeInElastic_helper(qreal t, qreal b, qreal c, qreal d, qreal a, qreal p)
 {
     if (t==0) return b;
-    qreal t_adj = (qreal)t / (qreal)d;
+    qreal t_adj = t / d;
     if (t_adj==1) return b+c;
 
     qreal s;
-    if(a < ::fabs(c)) {
+    if(a < ::qAbs(c)) {
         a = c;
-        s = p / 4.0f;
+        s = p * 0.25f;
     } else {
-        s = p / (2 * M_PI) * ::asin(c / a);
+        s = p / (Q_2PI) * ::qAsin(c / a);
     }
 
     t_adj -= 1.0f;
-    return -(a*::qPow(2.0f,10*t_adj) * ::sin( (t_adj*d-s)*(2*M_PI)/p )) + b;
+    return -(a*::qPow(2.0f,10*t_adj) * qSin( (t_adj*d-s)*(Q_2PI)/p )) + b;
 }
 
 /**
@@ -429,12 +423,12 @@ static qreal easeOutElastic_helper(qreal t, qreal /*b*/, qreal c, qreal /*d*/, q
     qreal s;
     if(a < c) {
         a = c;
-        s = p / 4.0f;
+        s = p * 0.25f;
     } else {
-        s = p / (2 * M_PI) * ::asin(c / a);
+        s = p / (Q_2PI) * ::qAsin(c / a);
     }
 
-    return (a*::qPow(2.0f,-10*t) * ::sin( (t-s)*(2*M_PI)/p ) + c);
+    return (a*::qPow(2.0f,-10*t) * ::qSin( (t-s)*(Q_2PI)/p ) + c);
 }
 
 /**
@@ -460,20 +454,20 @@ static qreal easeOutElastic(qreal t, qreal a, qreal p)
  */
 static qreal easeInOutElastic(qreal t, qreal a, qreal p)
 {
-    if (t==0) return 0.0;
-    t*=2.0;
-    if (t==2) return 1.0;
+    if (t==0) return qreal(0.0);
+    t*=qreal(2.0);
+    if (t==2) return qreal(1.0);
 
     qreal s;
-    if(a < 1.0) {
-        a = 1.0;
-        s = p / 4.0f;
+    if(a < qreal(1.0)) {
+        a = qreal(1.0);
+        s = p * 0.25f;
     } else {
-        s = p / (2 * M_PI) * ::asin(1.0 / a);
+        s = p / (Q_2PI) * ::qAsin(qreal(1.0) / a);
     }
 
-    if (t < 1) return -.5*(a*::qPow(2.0f,10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p ));
-    return a*::qPow(2.0f,-10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p )*.5 + 1.0;
+    if (t < 1) return qreal(-.5)*(a*::qPow(2.0f,10*(t-1)) * ::qSin( (t-1-s)*(Q_2PI)/p ));
+    return a*::qPow(2.0f,-10*(t-1)) * ::qSin( (t-1-s)*(Q_2PI)/p )*qreal(.5) + qreal(1.0);
 }
 
 /**
@@ -486,8 +480,8 @@ static qreal easeInOutElastic(qreal t, qreal a, qreal p)
  */
 static qreal easeOutInElastic(qreal t, qreal a, qreal p)
 {
-    if (t < 0.5) return easeOutElastic_helper(t*2, 0, 0.5, 1.0, a, p);
-    return easeInElastic_helper(2*t - 1.0, 0.5, 0.5, 1.0, a, p);
+    if (t < qreal(0.5)) return easeOutElastic_helper(t*2, 0, qreal(0.5), qreal(1.0), a, p);
+    return easeInElastic_helper(2*t - qreal(1.0), qreal(0.5), qreal(0.5), qreal(1.0), a, p);
 }
 
 /**
@@ -524,14 +518,14 @@ static qreal easeOutBack(qreal t, qreal s)
  */
 static qreal easeInOutBack(qreal t, qreal s)
 {
-    t *= 2.0;
+    t *= qreal(2.0);
     if (t < 1) {
         s *= 1.525f;
-        return 0.5*(t*t*((s+1)*t - s));
+        return qreal(0.5)*(t*t*((s+1)*t - s));
     } else {
         t -= 2;
         s *= 1.525f;
-        return 0.5*(t*t*((s+1)*t+ s) + 2);
+        return qreal(0.5)*(t*t*((s+1)*t+ s) + 2);
     }
 }
 
@@ -544,24 +538,26 @@ static qreal easeInOutBack(qreal t, qreal s)
  */
 static qreal easeOutInBack(qreal t, qreal s)
 {
-    if (t < 0.5) return easeOutBack (2*t, s)/2;
-    return easeInBack(2*t - 1, s)/2 + 0.5;
+    if (t < qreal(0.5)) return easeOutBack (2*t, s) * qreal(0.5);
+    return easeInBack(2*t - 1, s) * qreal(0.5) + qreal(0.5);
 }
 
 static qreal easeOutBounce_helper(qreal t, qreal c, qreal a)
 {
-    if (t == 1.0) return c;
-    if (t < (4/11.0)) {
-        return c*(7.5625*t*t);
-    } else if (t < (8/11.0)) {
-        t -= (6/11.0);
-        return -a * (1. - (7.5625*t*t + .75)) + c;
-    } else if (t < (10/11.0)) {
-        t -= (9/11.0);
-        return -a * (1. - (7.5625*t*t + .9375)) + c;
+    const qreal inv_22 = 1 / qreal(22.0);
+    const qreal inv_11 = 2 * inv_22;
+    if (t == qreal(1.0)) return c;
+    if (t < (4 * inv_11)) {
+        return c*(qreal(7.5625)*t*t);
+    } else if (t < (8 * inv_11)) {
+        t -= (6 * inv_11);
+        return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.75))) + c;
+    } else if (t < (10 * inv_11)) {
+        t -= (9 * inv_11);
+        return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.9375))) + c;
     } else {
-        t -= (21/22.0);
-        return -a * (1. - (7.5625*t*t + .984375)) + c;
+        t -= (21 * inv_22);
+        return -a * (qreal(1.) - (qreal(7.5625)*t*t + qreal(.984375))) + c;
     }
 }
 
@@ -586,7 +582,7 @@ static qreal easeOutBounce(qreal t, qreal a)
  */
 static qreal easeInBounce(qreal t, qreal a)
 {
-    return 1.0 - easeOutBounce_helper(1.0-t, 1.0, a);
+    return qreal(1.0) - easeOutBounce_helper(qreal(1.0)-t, qreal(1.0), a);
 }
 
 
@@ -599,8 +595,8 @@ static qreal easeInBounce(qreal t, qreal a)
  */
 static qreal easeInOutBounce(qreal t, qreal a)
 {
-    if (t < 0.5) return easeInBounce (2*t, a)/2;
-    else return (t == 1.0) ? 1.0 : easeOutBounce (2*t - 1, a)/2 + 0.5;
+    if (t < qreal(0.5)) return easeInBounce (2*t, a) * qreal(0.5);
+    else return (t == qreal(1.0)) ? qreal(1.0) : easeOutBounce (2*t - 1, a) * qreal(0.5) + qreal(0.5);
 }
 
 /**
@@ -612,13 +608,13 @@ static qreal easeInOutBounce(qreal t, qreal a)
  */
 static qreal easeOutInBounce(qreal t, qreal a)
 {
-    if (t < 0.5) return easeOutBounce_helper(t*2, 0.5, a);
-    return 1.0 - easeOutBounce_helper (2.0-2*t, 0.5, a);
+    if (t < qreal(0.5)) return easeOutBounce_helper(t*2, qreal(0.5), a);
+    return qreal(1.0) - easeOutBounce_helper (qreal(2.0)-2*t, qreal(0.5), a);
 }
 
 static inline qreal qt_sinProgress(qreal value)
 {
-    return qSin((value * M_PI) - M_PI_2) / 2 + qreal(0.5);
+    return qSin((value * Q_PI) - Q_PI2) * qreal(0.5) + qreal(0.5);
 }
 
 static inline qreal qt_smoothBeginEndMixFactor(qreal value)
@@ -656,7 +652,7 @@ static qreal easeOutCurve(qreal t)
  */
 static qreal easeSineCurve(qreal t)
 {
-    return (qSin(((t * M_PI * 2)) - M_PI_2) + 1) / 2;
+    return (qSin(((t * Q_2PI)) - Q_PI2) + 1) * qreal(0.5);
 }
 
 /**
@@ -665,6 +661,6 @@ static qreal easeSineCurve(qreal t)
  */
 static qreal easeCosineCurve(qreal t)
 {
-    return (qCos(((t * M_PI * 2)) - M_PI_2) + 1) / 2;
+    return (qCos(((t * Q_2PI)) - Q_PI2) + 1)  * qreal(0.5);
 }
 
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 9558256..6befb33 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -1081,14 +1081,14 @@ template <typename T>
 inline T qAbs(const T &t) { return t >= 0 ? t : -t; }
 
 inline int qRound(qreal d)
-{ return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); }
+{ return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1); }
 
 #if defined(QT_NO_FPU) || defined(QT_ARCH_ARM) || defined(QT_ARCH_WINDOWSCE) || defined(QT_ARCH_SYMBIAN)
 inline qint64 qRound64(double d)
 { return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qreal(qint64(d-1)) + 0.5) + qint64(d-1); }
 #else
 inline qint64 qRound64(qreal d)
-{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qreal(qint64(d-1)) + 0.5) + qint64(d-1); }
+{ return d >= 0.0 ? qint64(d + qreal(0.5)) : qint64(d - qreal(qint64(d-1)) + qreal(0.5)) + qint64(d-1); }
 #endif
 
 template <typename T>
diff --git a/src/corelib/global/qnumeric_p.h b/src/corelib/global/qnumeric_p.h
index c8b5735..3f7b5b5 100644
--- a/src/corelib/global/qnumeric_p.h
+++ b/src/corelib/global/qnumeric_p.h
@@ -57,6 +57,12 @@
 
 QT_BEGIN_NAMESPACE
 
+static const qreal Q_PI   = qreal(3.14159265358979323846);   // pi
+static const qreal Q_2PI  = qreal(6.28318530717958647693);   // 2*pi
+static const qreal Q_PI2  =  qreal(1.57079632679489661923);   // pi/2
+static const qreal Q_PI180  = qreal(0.01745329251994329577);   // pi/180
+static const qreal Q_180PI  = qreal(57.29577951308232087685);   // 180/pi
+
 #if !defined(Q_CC_MIPS)
 
 static const union { unsigned char c[8]; double d; } qt_be_inf_bytes = { { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } };
diff --git a/src/corelib/kernel/qmath.h b/src/corelib/kernel/qmath.h
index a9e4378..ef3a4b0 100644
--- a/src/corelib/kernel/qmath.h
+++ b/src/corelib/kernel/qmath.h
@@ -45,6 +45,7 @@
 #include <math.h>
 
 #include <QtCore/qglobal.h>
+#include <private/qnumeric_p.h>
 
 QT_BEGIN_HEADER
 
@@ -106,6 +107,16 @@ inline qreal qAcos(qreal v)
         return acos(v);
 }
 
+inline qreal qAsin(qreal v)
+{
+#ifdef QT_USE_MATH_H_FLOATS
+    if (sizeof(qreal) == sizeof(float))
+        return asinf(float(v));
+    else
+#endif
+        return asin(v);
+}
+
 inline qreal qSqrt(qreal v)
 {
 #ifdef QT_USE_MATH_H_FLOATS
@@ -136,28 +147,42 @@ inline qreal qPow(qreal x, qreal y)
         return pow(x, y);
 }
 
-#ifndef M_PI
-#define M_PI (3.14159265358979323846)
-#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 si = int(x * (qreal(0.5) * QT_SINE_TABLE_SIZE / Q_PI)); // Would be more accurate with qRound, but slower.
+    qreal d = x - si * (qreal(2.0) * Q_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;
+    return qt_sine_table[si] + (qt_sine_table[ci] - qreal(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 ci = int(x * (qreal(0.5) * QT_SINE_TABLE_SIZE / Q_PI)); // Would be more accurate with qRound, but slower.
+    qreal d = x - ci * (qreal(2.0) * Q_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;
+    return qt_sine_table[si] - (qt_sine_table[ci] + qreal(0.5) * qt_sine_table[si] * d) * d;
+}
+
+inline qreal qFabs(qreal x)
+{
+#ifdef QT_USE_MATH_H_FLOATS
+    if(sizeof(qreal) == sizeof(float))
+        return fabsf(x);
+#endif
+    return fabs(x);
+}
+
+inline qreal qAtan2(qreal x, qreal y)
+{
+#ifdef QT_USE_MATH_H_FLOATS
+    if(sizeof(qreal) == sizeof(float))
+        return atan2f(x, y);
+#endif
+    return atan2(x, y);
 }
 
 QT_END_NAMESPACE
diff --git a/src/corelib/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp
index db6435e..5ae2dde 100644
--- a/src/corelib/tools/qdatetime.cpp
+++ b/src/corelib/tools/qdatetime.cpp
@@ -1915,7 +1915,7 @@ QTime QTime::fromString(const QString& s, Qt::DateFormat f)
             const float msec(msec_s.toFloat(&ok));
             if (!ok)
                 return QTime();
-            return QTime(hour, minute, second, qMin(qRound(msec * 1000.0), 999));
+            return QTime(hour, minute, second, qMin(qRound(msec * qreal(1000.0)), 999));
         }
     }
 }
diff --git a/src/corelib/tools/qeasingcurve.cpp b/src/corelib/tools/qeasingcurve.cpp
index 3e1e1ee..a629ebc 100644
--- a/src/corelib/tools/qeasingcurve.cpp
+++ b/src/corelib/tools/qeasingcurve.cpp
@@ -317,7 +317,7 @@ class QEasingCurveFunction
 public:
     enum Type { In, Out, InOut, OutIn };
 
-    QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = 0.3, qreal amplitude = 1.0,
+    QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = qreal(0.3), qreal amplitude = qreal(1.0),
         qreal overshoot = 1.70158f)
         : _t(type), _p(period), _a(amplitude), _o(overshoot)
     { }
@@ -667,7 +667,7 @@ bool QEasingCurve::operator==(const QEasingCurve &other) const
  */
 qreal QEasingCurve::amplitude() const
 {
-    return d_ptr->config ? d_ptr->config->_a : 1.0;
+    return d_ptr->config ? d_ptr->config->_a : qreal(1.0);
 }
 
 /*!
@@ -691,7 +691,7 @@ void QEasingCurve::setAmplitude(qreal amplitude)
  */
 qreal QEasingCurve::period() const
 {
-    return d_ptr->config ? d_ptr->config->_p : 0.3;
+    return d_ptr->config ? d_ptr->config->_p : qreal(0.3);
 }
 
 /*!
@@ -742,9 +742,9 @@ QEasingCurve::Type QEasingCurve::type() const
 
 void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType)
 {
-    qreal amp = -1.0;
-    qreal period = -1.0;
-    qreal overshoot = -1.0;
+    qreal amp = qreal(-1.0);
+    qreal period = qreal(-1.0);
+    qreal overshoot = qreal(-1.0);
 
     if (config) {
         amp = config->_a;
@@ -754,13 +754,13 @@ void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType)
         config = 0;
     }
 
-    if (isConfigFunction(newType) || (amp != -1.0) || (period != -1.0) || (overshoot != -1.0)) {
+    if (isConfigFunction(newType) || (amp != qreal(-1.0)) || (period != qreal(-1.0)) || (overshoot != qreal(-1.0))) {
         config = curveToFunctionObject(newType);
-        if (amp != -1.0)
+        if (amp != qreal(-1.0))
             config->_a = amp;
-        if (period != -1.0)
+        if (period != qreal(-1.0))
             config->_p = period;
-        if (overshoot != -1.0)
+        if (overshoot != qreal(-1.0))
             config->_o = overshoot;
         func = 0;
     } else if (newType != QEasingCurve::Custom) {
diff --git a/src/corelib/tools/qline.cpp b/src/corelib/tools/qline.cpp
index d0afb7a..5b30c97 100644
--- a/src/corelib/tools/qline.cpp
+++ b/src/corelib/tools/qline.cpp
@@ -574,7 +574,7 @@ qreal QLineF::angle() const
     const qreal dx = pt2.x() - pt1.x();
     const qreal dy = pt2.y() - pt1.y();
 
-    const qreal theta = atan2(-dy, dx) * 360.0 / M_2PI;
+    const qreal theta = qAtan2(-dy, dx) * qreal(360.0) / Q_2PI;
 
     const qreal theta_normalized = theta < 0 ? theta + 360 : theta;
 
@@ -598,7 +598,7 @@ qreal QLineF::angle() const
 */
 void QLineF::setAngle(qreal angle)
 {
-    const qreal angleR = angle * M_2PI / 360.0;
+    const qreal angleR = angle * Q_2PI / qreal(360.0);
     const qreal l = length();
 
     const qreal dx = qCos(angleR) * l;
@@ -620,7 +620,7 @@ void QLineF::setAngle(qreal angle)
 */
 QLineF QLineF::fromPolar(qreal length, qreal angle)
 {
-    const qreal angleR = angle * M_2PI / 360.0;
+    const qreal angleR = angle * Q_2PI / qreal(360.0);
     return QLineF(0, 0, qCos(angleR) * length, -qSin(angleR) * length);
 }
 
@@ -639,7 +639,7 @@ QLineF QLineF::unitVector() const
     QLineF f(p1(), QPointF(pt1.x() + x/len, pt1.y() + y/len));
 
 #ifndef QT_NO_DEBUG
-    if (qAbs(f.length() - 1) >= 0.001)
+    if (qAbs(f.length() - 1) >= qreal(0.001))
         qWarning("QLine::unitVector: New line does not have unit length");
 #endif
 
@@ -814,8 +814,8 @@ qreal QLineF::angle(const QLineF &l) const
     qreal cos_line = (dx()*l.dx() + dy()*l.dy()) / (length()*l.length());
     qreal rad = 0;
     // only accept cos_line in the range [-1,1], if it is outside, use 0 (we return 0 rather than PI for those cases)
-    if (cos_line >= -1.0 && cos_line <= 1.0) rad = acos( cos_line );
-    return rad * 360 / M_2PI;
+    if (cos_line >= qreal(-1.0) && cos_line <= qreal(1.0)) rad = qAcos( cos_line );
+    return rad * 360 / Q_2PI;
 }
 
 
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 2fd499d..b6172ab 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -8371,8 +8371,9 @@ QPainterPath QGraphicsEllipseItem::shape() const
     if (d->rect.isNull())
         return path;
     if (d->spanAngle != 360 * 16) {
+        const qreal inv_16 = 1 / qreal(16.0);
         path.moveTo(d->rect.center());
-        path.arcTo(d->rect, d->startAngle / 16.0, d->spanAngle / 16.0);
+        path.arcTo(d->rect, d->startAngle * inv_16, d->spanAngle * inv_16);
     } else {
         path.addEllipse(d->rect);
     }
diff --git a/src/gui/graphicsview/qgraphicsitemanimation.cpp b/src/gui/graphicsview/qgraphicsitemanimation.cpp
index be2f300..1516e46 100644
--- a/src/gui/graphicsview/qgraphicsitemanimation.cpp
+++ b/src/gui/graphicsview/qgraphicsitemanimation.cpp
@@ -165,7 +165,7 @@ qreal QGraphicsItemAnimationPrivate::linearValueForStep(qreal step, QList<Pair>
 
 void QGraphicsItemAnimationPrivate::insertUniquePair(qreal step, qreal value, QList<Pair> *binList, const char* method)
 {
-    if (step < 0.0 || step > 1.0) {
+    if (step < qreal(0.0) || step > qreal(1.0)) {
         qWarning("QGraphicsItemAnimation::%s: invalid step = %f", method, step);
         return;
     }
@@ -255,7 +255,7 @@ void QGraphicsItemAnimation::setTimeLine(QTimeLine *timeLine)
 */
 QPointF QGraphicsItemAnimation::posAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::posAt: invalid step = %f", step);
 
     return QPointF(d->linearValueForStep(step, &d->xPosition, d->startPos.x()),
@@ -294,7 +294,7 @@ QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::posList() const
 */
 QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::matrixAt: invalid step = %f", step);
 
     QMatrix matrix;
@@ -316,7 +316,7 @@ QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const
 */
 qreal QGraphicsItemAnimation::rotationAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::rotationAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->rotation);
@@ -405,7 +405,7 @@ QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::translationList() const
 */
 qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::verticalScaleAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->verticalScale, 1);
@@ -418,7 +418,7 @@ qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const
 */
 qreal QGraphicsItemAnimation::horizontalScaleAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::horizontalScaleAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->horizontalScale, 1);
@@ -457,7 +457,7 @@ QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::scaleList() const
 */
 qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::verticalShearAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->verticalShear, 0);
@@ -470,7 +470,7 @@ qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const
 */
 qreal QGraphicsItemAnimation::horizontalShearAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::horizontalShearAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->horizontalShear, 0);
@@ -527,7 +527,7 @@ void QGraphicsItemAnimation::clear()
 */
 void QGraphicsItemAnimation::setStep(qreal x)
 {
-    if (x < 0.0 || x > 1.0) {
+    if (x < qreal(0.0) || x > qreal(1.0)) {
         qWarning("QGraphicsItemAnimation::setStep: invalid step = %f", x);
         return;
     }
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index dc036f8..8431fe9 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -4109,13 +4109,13 @@ static void _q_paintItem(QGraphicsItem *item, QPainter *painter,
     QGraphicsWidget *widgetItem = static_cast<QGraphicsWidget *>(item);
     QGraphicsProxyWidget *proxy = qobject_cast<QGraphicsProxyWidget *>(widgetItem);
     const qreal windowOpacity = (proxy && proxy->widget() && useWindowOpacity)
-                                ? proxy->widget()->windowOpacity() : 1.0;
+                                ? proxy->widget()->windowOpacity() : qreal(1.0);
     const qreal oldPainterOpacity = painter->opacity();
 
     if (qFuzzyIsNull(windowOpacity))
         return;
     // Set new painter opacity.
-    if (windowOpacity < 1.0)
+    if (windowOpacity < qreal(1.0))
         painter->setOpacity(oldPainterOpacity * windowOpacity);
 
     // set layoutdirection on the painter
@@ -4209,7 +4209,7 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
     QGraphicsProxyWidget *proxy = item->isWidget() ? qobject_cast<QGraphicsProxyWidget *>(static_cast<QGraphicsWidget *>(item)) : 0;
     if (proxy && proxy->widget()) {
         const qreal windowOpacity = proxy->widget()->windowOpacity();
-        if (windowOpacity < 1.0)
+        if (windowOpacity < qreal(1.0))
             newPainterOpacity *= windowOpacity;
     }
 
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index c88f678..7ac1a8f 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -297,7 +297,7 @@ inline int q_round_bound(qreal d) //### (int)(qreal) INT_MAX != INT_MAX for sing
         return INT_MIN;
     else if (d >= (qreal) INT_MAX)
         return INT_MAX;
-    return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1);
+    return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1);
 }
 
 void QGraphicsViewPrivate::translateTouchEvent(QGraphicsViewPrivate *d, QTouchEvent *touchEvent)
diff --git a/src/gui/graphicsview/qgraphicswidget_p.cpp b/src/gui/graphicsview/qgraphicswidget_p.cpp
index b747a30..7847635 100644
--- a/src/gui/graphicsview/qgraphicswidget_p.cpp
+++ b/src/gui/graphicsview/qgraphicswidget_p.cpp
@@ -457,13 +457,13 @@ static QSizeF closestAcceptableSize(const QSizeF &proposed,
     min_hfw = minimumHeightForWidth(maxw, minh, maxh, widget);
 
     do {
-        if (maxw - minw < 0.1) {
+        if (maxw - minw < qreal(0.1)) {
             // we still havent found anything, cut off binary search
             minw = maxw;
             minh = maxh;
         }
-        middlew = minw + (maxw - minw)/2.0;
-        middleh = minh + (maxh - minh)/2.0;
+        middlew = minw + (maxw - minw) * qreal(0.5);
+        middleh = minh + (maxh - minh) * qreal(0.5);
 
         min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);
 
diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp
index f61360a..f6fa16b 100644
--- a/src/gui/graphicsview/qgridlayoutengine.cpp
+++ b/src/gui/graphicsview/qgridlayoutengine.cpp
@@ -69,21 +69,22 @@ static void insertOrRemoveItems(QVector<T> &items, int index, int delta)
 
 static qreal growthFactorBelowPreferredSize(qreal desired, qreal sumAvailable, qreal sumDesired)
 {
-    Q_ASSERT(sumDesired != 0.0);
-    return desired * ::pow(sumAvailable / sumDesired, desired / sumDesired);
+    Q_ASSERT(sumDesired != qreal(0.0));
+    const qreal inv_sumDesired = 1 / sumDesired;
+    return desired * ::pow(sumAvailable * inv_sumDesired, desired * inv_sumDesired);
 }
 
 static qreal fixedDescent(qreal descent, qreal ascent, qreal targetSize)
 {
-    if (descent < 0.0)
-        return -1.0;
+    if (descent < qreal(0.0))
+        return qreal(-1.0);
 
-    Q_ASSERT(descent >= 0.0);
-    Q_ASSERT(ascent >= 0.0);
+    Q_ASSERT(descent >= qreal(0.0));
+    Q_ASSERT(ascent >= qreal(0.0));
     Q_ASSERT(targetSize >= ascent + descent);
 
     qreal extra = targetSize - (ascent + descent);
-    return descent + (extra / 2.0);
+    return descent + (extra * qreal(0.5));
 }
 
 static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int which)
@@ -100,7 +101,7 @@ static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int
 
 void QGridLayoutBox::add(const QGridLayoutBox &other, int stretch, qreal spacing)
 {
-    Q_ASSERT(q_minimumDescent < 0.0);
+    Q_ASSERT(q_minimumDescent < qreal(0.0));
 
     q_minimumSize += other.q_minimumSize + spacing;
     q_preferredSize += other.q_preferredSize + spacing;
@@ -134,7 +135,7 @@ void QGridLayoutBox::normalize()
     q_preferredSize = qBound(q_minimumSize, q_preferredSize, q_maximumSize);
     q_minimumDescent = qMin(q_minimumDescent, q_minimumSize);
 
-    Q_ASSERT((q_minimumDescent < 0.0) == (q_minimumAscent < 0.0));
+    Q_ASSERT((q_minimumDescent < qreal(0.0)) == (q_minimumAscent < qreal(0.0)));
 }
 
 #ifdef QT_DEBUG
@@ -161,7 +162,7 @@ void QGridLayoutRowData::reset(int count)
     boxes.fill(QGridLayoutBox(), count);
     multiCellMap.clear();
     stretches.fill(0, count);
-    spacings.fill(0.0, count);
+    spacings.fill(qreal(0.0), count);
     hasIgnoreFlag = false;
 }
 
@@ -182,7 +183,7 @@ void QGridLayoutRowData::distributeMultiCells()
 
         for (int j = 0; j < NSizes; ++j) {
             qreal extra = compare(totalBox, box, j);
-            if (extra > 0.0) {
+            if (extra > qreal(0.0)) {
                 calculateGeometries(start, end, totalBox.q_sizes(j), dummy.data(), newSizes.data(),
                                     0, totalBox);
 
@@ -210,7 +211,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
     int n = end - start;
     QVarLengthArray<qreal> newSizes(n);
     QVarLengthArray<qreal> factors(n);
-    qreal sumFactors = 0.0;
+    qreal sumFactors = qreal(0.0);
     int sumStretches = 0;
     qreal sumAvailable;
 
@@ -223,24 +224,25 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
         stealBox(start, end, MinimumSize, positions, sizes);
 
         sumAvailable = targetSize - totalBox.q_minimumSize;
-        if (sumAvailable > 0.0) {
-            qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize;
+        if (sumAvailable > qreal(0.0)) {
+            const qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize;
 
             for (int i = 0; i < n; ++i) {
                 if (ignore.testBit(start + i)) {
-                    factors[i] = 0.0;
+                    factors[i] = qreal(0.0);
                     continue;
                 }
 
                 const QGridLayoutBox &box = boxes.at(start + i);
-                qreal desired = box.q_preferredSize - box.q_minimumSize;
+                const qreal desired = box.q_preferredSize - box.q_minimumSize;
                 factors[i] = growthFactorBelowPreferredSize(desired, sumAvailable, sumDesired);
                 sumFactors += factors[i];
             }
 
+            const qreal inv_sumFactors = 1 / sumFactors;
             for (int i = 0; i < n; ++i) {
-                Q_ASSERT(sumFactors > 0.0);
-                qreal delta = sumAvailable * factors[i] / sumFactors;
+                Q_ASSERT(sumFactors > qreal(0.0));
+                const qreal delta = sumAvailable * factors[i] * inv_sumFactors;
                 newSizes[i] = sizes[i] + delta;
             }
         }
@@ -248,46 +250,46 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
         stealBox(start, end, PreferredSize, positions, sizes);
 
         sumAvailable = targetSize - totalBox.q_preferredSize;
-        if (sumAvailable > 0.0) {
+        if (sumAvailable > qreal(0.0)) {
             bool somethingHasAMaximumSize = false;
 
-            qreal sumPreferredSizes = 0.0;
+            qreal sumPreferredSizes = qreal(0.0);
             for (int i = 0; i < n; ++i)
                 sumPreferredSizes += sizes[i];
 
             for (int i = 0; i < n; ++i) {
                 if (ignore.testBit(start + i)) {
-                    newSizes[i] = 0.0;
-                    factors[i] = 0.0;
+                    newSizes[i] = qreal(0.0);
+                    factors[i] = qreal(0.0);
                     continue;
                 }
 
                 const QGridLayoutBox &box = boxes.at(start + i);
-                qreal desired = box.q_maximumSize - box.q_preferredSize;
-                if (desired == 0.0) {
+                const qreal desired = box.q_maximumSize - box.q_preferredSize;
+                if (desired == qreal(0.0)) {
                     newSizes[i] = sizes[i];
-                    factors[i] = 0.0;
+                    factors[i] = qreal(0.0);
                 } else {
-                    Q_ASSERT(desired > 0.0);
+                    Q_ASSERT(desired > qreal(0.0));
 
                     int stretch = stretches[start + i];
                     if (sumStretches == 0) {
                         if (hasIgnoreFlag) {
-                            factors[i] = (stretch < 0) ? 1.0 : 0.0;
+                            factors[i] = (stretch < 0) ? qreal(1.0) : qreal(0.0);
                         } else {
-                            factors[i] = (stretch < 0) ? sizes[i] : 0.0;
+                            factors[i] = (stretch < 0) ? sizes[i] : qreal(0.0);
                         }
                     } else if (stretch == sumStretches) {
-                        factors[i] = 1.0;
+                        factors[i] = qreal(1.0);
                     } else if (stretch <= 0) {
-                        factors[i] = 0.0;
+                        factors[i] = qreal(0.0);
                     } else {
                         qreal ultimatePreferredSize;
                         qreal ultimateSumPreferredSizes;
                         qreal x = ((stretch * sumPreferredSizes)
                                    - (sumStretches * box.q_preferredSize))
                                   / (sumStretches - stretch);
-                        if (x >= 0.0) {
+                        if (x >= qreal(0.0)) {
                             ultimatePreferredSize = box.q_preferredSize + x;
                             ultimateSumPreferredSizes = sumPreferredSizes + x;
                         } else {
@@ -301,8 +303,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                             (at the expense of the stretch factors, which are not fully respected
                             during the transition).
                         */
-                        ultimatePreferredSize = ultimatePreferredSize * 3 / 2;
-                        ultimateSumPreferredSizes = ultimateSumPreferredSizes * 3 / 2;
+                        ultimatePreferredSize = ultimatePreferredSize * qreal(1.5);
+                        ultimateSumPreferredSizes = ultimateSumPreferredSizes * qreal(1.5);
 
                         qreal ultimateFactor = (stretch * ultimateSumPreferredSizes
                                                 / sumStretches)
@@ -323,7 +325,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                     if (desired < sumAvailable)
                         somethingHasAMaximumSize = true;
 
-                    newSizes[i] = -1.0;
+                    newSizes[i] = qreal(-1.0);
                 }
             }
 
@@ -332,7 +334,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                 keepGoing = false;
 
                 for (int i = 0; i < n; ++i) {
-                    if (newSizes[i] >= 0.0)
+                    if (newSizes[i] >= qreal(0.0))
                         continue;
 
                     const QGridLayoutBox &box = boxes.at(start + i);
@@ -341,7 +343,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                         newSizes[i] = box.q_maximumSize;
                         sumAvailable -= box.q_maximumSize - sizes[i];
                         sumFactors -= factors[i];
-                        keepGoing = (sumAvailable > 0.0);
+                        keepGoing = (sumAvailable > qreal(0.0));
                         if (!keepGoing)
                             break;
                     }
@@ -349,8 +351,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
             }
 
             for (int i = 0; i < n; ++i) {
-                if (newSizes[i] < 0.0) {
-                    qreal delta = (sumFactors == 0.0) ? 0.0
+                if (newSizes[i] < qreal(0.0)) {
+                    qreal delta = (sumFactors == qreal(0.0)) ? qreal(0.0)
                                                       : sumAvailable * factors[i] / sumFactors;
                     newSizes[i] = sizes[i] + delta;
                 }
@@ -406,8 +408,8 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const
 {
     QGridLayoutBox result;
     if (start < end) {
-        result.q_maximumSize = 0.0;
-        qreal nextSpacing = 0.0;
+        result.q_maximumSize = qreal(0.0);
+        qreal nextSpacing = qreal(0.0);
         for (int i = start; i < end; ++i) {
             result.add(boxes.at(i), stretches.at(i), nextSpacing);
             nextSpacing = spacings.at(i);
@@ -418,11 +420,11 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const
 
 void QGridLayoutRowData::stealBox(int start, int end, int which, qreal *positions, qreal *sizes)
 {
-    qreal offset = 0.0;
-    qreal nextSpacing = 0.0;
+    qreal offset = qreal(0.0);
+    qreal nextSpacing = qreal(0.0);
 
     for (int i = start; i < end; ++i) {
-        qreal avail = 0.0;
+        qreal avail = qreal(0.0);
 
         if (!ignore.testBit(i)) {
             const QGridLayoutBox &box = boxes.at(i);
diff --git a/src/gui/graphicsview/qsimplex_p.cpp b/src/gui/graphicsview/qsimplex_p.cpp
index 86b10b4..5ad329e 100644
--- a/src/gui/graphicsview/qsimplex_p.cpp
+++ b/src/gui/graphicsview/qsimplex_p.cpp
@@ -485,8 +485,8 @@ bool QSimplex::iterate()
 
     // Normalize Pivot Row
     qreal pivot = valueAt(pivotRow, pivotColumn);
-    if (pivot != 1.0)
-        combineRows(pivotRow, pivotRow, (1.0 - pivot) / pivot);
+    if (pivot != qreal(1.0))
+        combineRows(pivotRow, pivotRow, (qreal(1.0) - pivot) / pivot);
 
     // Update other rows
     for (int row=0; row < rows; ++row) {
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 21ca1e3..2cf8597 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -5313,19 +5313,19 @@ int QImage::metric(PaintDeviceMetric metric) const
         break;
 
     case PdmDpiX:
-        return qRound(d->dpmx * 0.0254);
+        return qRound(d->dpmx * qreal(0.0254));
         break;
 
     case PdmDpiY:
-        return qRound(d->dpmy * 0.0254);
+        return qRound(d->dpmy * qreal(0.0254));
         break;
 
     case PdmPhysicalDpiX:
-        return qRound(d->dpmx * 0.0254);
+        return qRound(d->dpmx * qreal(0.0254));
         break;
 
     case PdmPhysicalDpiY:
-        return qRound(d->dpmy * 0.0254);
+        return qRound(d->dpmy * qreal(0.0254));
         break;
 
     default:
@@ -5391,12 +5391,12 @@ bool qt_xForm_helper(const QTransform &trueMat, int xoffset, int type, int depth
                      uchar *dptr, int dbpl, int p_inc, int dHeight,
                      const uchar *sptr, int sbpl, int sWidth, int sHeight)
 {
-    int m11 = int(trueMat.m11()*4096.0);
-    int m12 = int(trueMat.m12()*4096.0);
-    int m21 = int(trueMat.m21()*4096.0);
-    int m22 = int(trueMat.m22()*4096.0);
-    int dx  = qRound(trueMat.dx()*4096.0);
-    int dy  = qRound(trueMat.dy()*4096.0);
+    int m11 = int(trueMat.m11()*qreal(4096.0));
+    int m12 = int(trueMat.m12()*qreal(4096.0));
+    int m21 = int(trueMat.m21()*qreal(4096.0));
+    int m22 = int(trueMat.m22()*qreal(4096.0));
+    int dx  = qRound(trueMat.dx()*qreal(4096.0));
+    int dy  = qRound(trueMat.dy()*qreal(4096.0));
 
     int m21ydx = dx + (xoffset<<16) + (m11 + m21) / 2;
     int m22ydy = dy + (m12 + m22) / 2;
@@ -5980,22 +5980,22 @@ QImage QImage::transformed(const QTransform &matrix, Qt::TransformationMode mode
     if (mat.type() <= QTransform::TxScale) {
         if (mat.type() == QTransform::TxNone) // identity matrix
             return *this;
-        else if (mat.m11() == -1. && mat.m22() == -1.)
+        else if (mat.m11() == qreal(-1.) && mat.m22() == qreal(-1.))
             return rotated180(*this);
 
         if (mode == Qt::FastTransformation) {
             hd = qRound(qAbs(mat.m22()) * hs);
             wd = qRound(qAbs(mat.m11()) * ws);
         } else {
-            hd = int(qAbs(mat.m22()) * hs + 0.9999);
-            wd = int(qAbs(mat.m11()) * ws + 0.9999);
+            hd = int(qAbs(mat.m22()) * hs + qreal(0.9999));
+            wd = int(qAbs(mat.m11()) * ws + qreal(0.9999));
         }
         scale_xform = true;
     } else {
         if (mat.type() <= QTransform::TxRotate && mat.m11() == 0 && mat.m22() == 0) {
-            if (mat.m12() == 1. && mat.m21() == -1.)
+            if (mat.m12() == qreal(1.) && mat.m21() == qreal(-1.))
                 return rotated90(*this);
-            else if (mat.m12() == -1. && mat.m21() == 1.)
+            else if (mat.m12() == qreal(-1.) && mat.m21() == qreal(1.))
                 return rotated270(*this);
         }
 
diff --git a/src/gui/image/qpaintengine_pic.cpp b/src/gui/image/qpaintengine_pic.cpp
index 80b16cf..b6fea8b 100644
--- a/src/gui/image/qpaintengine_pic.cpp
+++ b/src/gui/image/qpaintengine_pic.cpp
@@ -342,7 +342,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr)
     }
     d->pic_d->pictb.seek(newpos);                  // set to new position
 
-    if (br.width() > 0.0 || br.height() > 0.0) {
+    if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) {
         if (corr) {                             // widen bounding rect
             int w2 = painter()->pen().width() / 2;
             br.setCoords(br.left() - w2, br.top() - w2,
@@ -354,7 +354,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr)
             br &= cr;
         }
 
-        if (br.width() > 0.0 || br.height() > 0.0) {
+        if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) {
             int minx = qFloor(br.left());
             int miny = qFloor(br.top());
             int maxx = qCeil(br.right());
diff --git a/src/gui/image/qpicture.cpp b/src/gui/image/qpicture.cpp
index f502827..39a4fcc 100644
--- a/src/gui/image/qpicture.cpp
+++ b/src/gui/image/qpicture.cpp
@@ -967,10 +967,10 @@ int QPicture::metric(PaintDeviceMetric m) const
             val = brect.height();
             break;
         case PdmWidthMM:
-            val = int(25.4/qt_defaultDpiX()*brect.width());
+            val = int(qreal(25.4)/qt_defaultDpiX()*brect.width());
             break;
         case PdmHeightMM:
-            val = int(25.4/qt_defaultDpiY()*brect.height());
+            val = int(qreal(25.4)/qt_defaultDpiY()*brect.height());
             break;
         case PdmDpiX:
         case PdmPhysicalDpiX:
diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp
index fc76dc3..8560e5d 100644
--- a/src/gui/image/qpixmap_raster.cpp
+++ b/src/gui/image/qpixmap_raster.cpp
@@ -373,9 +373,9 @@ int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
     case QPaintDevice::PdmHeight:
         return h;
     case QPaintDevice::PdmWidthMM:
-        return qRound(d->width * 25.4 / qt_defaultDpiX());
+        return qRound(d->width * qreal(25.4) / qt_defaultDpiX());
     case QPaintDevice::PdmHeightMM:
-        return qRound(d->width * 25.4 / qt_defaultDpiY());
+        return qRound(d->width * qreal(25.4) / qt_defaultDpiY());
     case QPaintDevice::PdmNumColors:
         return d->colortable.size();
     case QPaintDevice::PdmDepth:
diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp
index cd8a4d4..6a999b4 100644
--- a/src/gui/image/qpixmap_s60.cpp
+++ b/src/gui/image/qpixmap_s60.cpp
@@ -568,6 +568,7 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
     if (!cfbsBitmap)
         return 0;
 
+    qreal div_by_KTwipsPerInch = 1 / (qreal)KTwipsPerInch;
     switch (metric) {
     case QPaintDevice::PdmWidth:
         return cfbsBitmap->SizeInPixels().iWidth;
@@ -575,23 +576,23 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
         return cfbsBitmap->SizeInPixels().iHeight;
     case QPaintDevice::PdmWidthMM: {
         TInt twips = cfbsBitmap->SizeInTwips().iWidth;
-        return (int)(twips * (25.4/KTwipsPerInch));
+        return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch));
     }
     case QPaintDevice::PdmHeightMM: {
         TInt twips = cfbsBitmap->SizeInTwips().iHeight;
-        return (int)(twips * (25.4/KTwipsPerInch));
+        return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch));
     }
     case QPaintDevice::PdmNumColors:
         return TDisplayModeUtils::NumDisplayModeColors(cfbsBitmap->DisplayMode());
     case QPaintDevice::PdmDpiX:
     case QPaintDevice::PdmPhysicalDpiX: {
-        TReal inches = cfbsBitmap->SizeInTwips().iWidth / (TReal)KTwipsPerInch;
+        qreal inches = cfbsBitmap->SizeInTwips().iWidth * div_by_KTwipsPerInch;
         TInt pixels = cfbsBitmap->SizeInPixels().iWidth;
         return pixels / inches;
     }
     case QPaintDevice::PdmDpiY:
     case QPaintDevice::PdmPhysicalDpiY: {
-        TReal inches = cfbsBitmap->SizeInTwips().iHeight / (TReal)KTwipsPerInch;
+        qreal inches = cfbsBitmap->SizeInTwips().iHeight * div_by_KTwipsPerInch;
         TInt pixels = cfbsBitmap->SizeInPixels().iHeight;
         return pixels / inches;
     }
diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp
index 44d689d..e520c63 100644
--- a/src/gui/image/qpnghandler.cpp
+++ b/src/gui/image/qpnghandler.cpp
@@ -732,8 +732,8 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
         png_set_compression_level(png_ptr, quality);
     }
 
-    if (gamma != 0.0) {
-        png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
+    if (gamma != qreal(0.0)) {
+        png_set_gAMA(png_ptr, info_ptr, qreal(1.0)/gamma);
     }
 
     png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp
index 2c3d616..031c5ef 100644
--- a/src/gui/math3d/qmatrix4x4.cpp
+++ b/src/gui/math3d/qmatrix4x4.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "qmatrix4x4.h"
+#include <private/qnumeric_p.h>
 #include <QtCore/qmath.h>
 #include <QtCore/qvariant.h>
 #include <QtGui/qmatrix.h>
@@ -58,7 +59,7 @@ QT_BEGIN_NAMESPACE
     \sa QVector3D, QGenericMatrix
 */
 
-static const qreal inv_dist_to_plane = 1. / 1024.;
+static const qreal inv_dist_to_plane = qreal(1.) / qreal(1024.);
 
 /*!
     \fn QMatrix4x4::QMatrix4x4()
@@ -506,22 +507,23 @@ QMatrix4x4 QMatrix4x4::transposed() const
 */
 QMatrix4x4& QMatrix4x4::operator/=(qreal divisor)
 {
-    m[0][0] /= divisor;
-    m[0][1] /= divisor;
-    m[0][2] /= divisor;
-    m[0][3] /= divisor;
-    m[1][0] /= divisor;
-    m[1][1] /= divisor;
-    m[1][2] /= divisor;
-    m[1][3] /= divisor;
-    m[2][0] /= divisor;
-    m[2][1] /= divisor;
-    m[2][2] /= divisor;
-    m[2][3] /= divisor;
-    m[3][0] /= divisor;
-    m[3][1] /= divisor;
-    m[3][2] /= divisor;
-    m[3][3] /= divisor;
+    const qreal inv_divisor = (1 / divisor); 
+    m[0][0] *= inv_divisor;
+    m[0][1] *= inv_divisor;
+    m[0][2] *= inv_divisor;
+    m[0][3] *= inv_divisor;
+    m[1][0] *= inv_divisor;
+    m[1][1] *= inv_divisor;
+    m[1][2] *= inv_divisor;
+    m[1][3] *= inv_divisor;
+    m[2][0] *= inv_divisor;
+    m[2][1] *= inv_divisor;
+    m[2][2] *= inv_divisor;
+    m[2][3] *= inv_divisor;
+    m[3][0] *= inv_divisor;
+    m[3][1] *= inv_divisor;
+    m[3][2] *= inv_divisor;
+    m[3][3] *= inv_divisor;
     flagBits = General;
     return *this;
 }
@@ -662,23 +664,24 @@ QMatrix4x4& QMatrix4x4::operator/=(qreal divisor)
 */
 QMatrix4x4 operator/(const QMatrix4x4& matrix, qreal divisor)
 {
+    const qreal inv_divisor = (1 / divisor);
     QMatrix4x4 m(1); // The "1" says to not load the identity.
-    m.m[0][0] = matrix.m[0][0] / divisor;
-    m.m[0][1] = matrix.m[0][1] / divisor;
-    m.m[0][2] = matrix.m[0][2] / divisor;
-    m.m[0][3] = matrix.m[0][3] / divisor;
-    m.m[1][0] = matrix.m[1][0] / divisor;
-    m.m[1][1] = matrix.m[1][1] / divisor;
-    m.m[1][2] = matrix.m[1][2] / divisor;
-    m.m[1][3] = matrix.m[1][3] / divisor;
-    m.m[2][0] = matrix.m[2][0] / divisor;
-    m.m[2][1] = matrix.m[2][1] / divisor;
-    m.m[2][2] = matrix.m[2][2] / divisor;
-    m.m[2][3] = matrix.m[2][3] / divisor;
-    m.m[3][0] = matrix.m[3][0] / divisor;
-    m.m[3][1] = matrix.m[3][1] / divisor;
-    m.m[3][2] = matrix.m[3][2] / divisor;
-    m.m[3][3] = matrix.m[3][3] / divisor;
+    m.m[0][0] = matrix.m[0][0] * inv_divisor;
+    m.m[0][1] = matrix.m[0][1] * inv_divisor;
+    m.m[0][2] = matrix.m[0][2] * inv_divisor;
+    m.m[0][3] = matrix.m[0][3] * inv_divisor;
+    m.m[1][0] = matrix.m[1][0] * inv_divisor;
+    m.m[1][1] = matrix.m[1][1] * inv_divisor;
+    m.m[1][2] = matrix.m[1][2] * inv_divisor;
+    m.m[1][3] = matrix.m[1][3] * inv_divisor;
+    m.m[2][0] = matrix.m[2][0] * inv_divisor;
+    m.m[2][1] = matrix.m[2][1] * inv_divisor;
+    m.m[2][2] = matrix.m[2][2] * inv_divisor;
+    m.m[2][3] = matrix.m[2][3] * inv_divisor;
+    m.m[3][0] = matrix.m[3][0] * inv_divisor;
+    m.m[3][1] = matrix.m[3][1] * inv_divisor;
+    m.m[3][2] = matrix.m[3][2] * inv_divisor;
+    m.m[3][3] = matrix.m[3][3] * inv_divisor;
     return m;
 }
 
@@ -1011,7 +1014,7 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z)
         s = 0.0f;
         c = -1.0f;
     } else {
-        qreal a = angle * M_PI / 180.0f;
+        qreal a = angle * Q_PI180;
         c = qCos(a);
         s = qSin(a);
     }
@@ -1066,10 +1069,11 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z)
     if (!quick) {
         qreal len = x * x + y * y + z * z;
         if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) {
+            const qreal inv_len = 1 / len;
             len = qSqrt(len);
-            x /= len;
-            y /= len;
-            z /= len;
+            x *= inv_len;
+            y *= inv_len;
+            z *= inv_len;
         }
         ic = 1.0f - c;
         m.m[0][0] = x * x * ic + c;
@@ -1118,7 +1122,7 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z)
         s = 0.0f;
         c = -1.0f;
     } else {
-        qreal a = angle * M_PI / 180.0f;
+        qreal a = angle * Q_PI180;
         c = qCos(a);
         s = qSin(a);
     }
@@ -1169,10 +1173,11 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z)
     if (!quick) {
         qreal len = x * x + y * y + z * z;
         if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) {
+            const qreal inv_len = 1 / len;
             len = qSqrt(len);
-            x /= len;
-            y /= len;
-            z /= len;
+            x *= inv_len;
+            y *= inv_len;
+            z *= inv_len;
         }
         ic = 1.0f - c;
         m.m[0][0] = x * x * ic + c;
@@ -1299,35 +1304,39 @@ void QMatrix4x4::ortho(qreal left, qreal right, qreal bottom, qreal top, qreal n
     qreal width = right - left;
     qreal invheight = top - bottom;
     qreal clip = farPlane - nearPlane;
+    qreal inv_width = 1 / width;
+    qreal inv_invheight = 1 / invheight;
+    qreal inv_clip = 1 / clip;
 #ifndef QT_NO_VECTOR3D
     if (clip == 2.0f && (nearPlane + farPlane) == 0.0f) {
         // We can express this projection as a translate and scale
         // which will be more efficient to modify with further
         // transformations than producing a "General" matrix.
+
         translate(QVector3D
-            (-(left + right) / width,
-             -(top + bottom) / invheight,
+            (-(left + right) * inv_width,
+             -(top + bottom) * inv_invheight,
              0.0f));
         scale(QVector3D
-            (2.0f / width,
-             2.0f / invheight,
+            (2.0f * inv_width,
+             2.0f * inv_invheight,
              -1.0f));
         return;
     }
 #endif
     QMatrix4x4 m(1);
-    m.m[0][0] = 2.0f / width;
+    m.m[0][0] = 2.0f * inv_width;
     m.m[1][0] = 0.0f;
     m.m[2][0] = 0.0f;
-    m.m[3][0] = -(left + right) / width;
+    m.m[3][0] = -(left + right) * inv_width;
     m.m[0][1] = 0.0f;
-    m.m[1][1] = 2.0f / invheight;
+    m.m[1][1] = 2.0f * inv_invheight;
     m.m[2][1] = 0.0f;
-    m.m[3][1] = -(top + bottom) / invheight;
+    m.m[3][1] = -(top + bottom) * inv_invheight;
     m.m[0][2] = 0.0f;
     m.m[1][2] = 0.0f;
-    m.m[2][2] = -2.0f / clip;
-    m.m[3][2] = -(nearPlane + farPlane) / clip;
+    m.m[2][2] = -2.0f * inv_clip;
+    m.m[3][2] = -(nearPlane + farPlane) * inv_clip;
     m.m[0][3] = 0.0f;
     m.m[1][3] = 0.0f;
     m.m[2][3] = 0.0f;
@@ -1354,21 +1363,24 @@ void QMatrix4x4::frustum(qreal left, qreal right, qreal bottom, qreal top, qreal
 
     // Construct the projection.
     QMatrix4x4 m(1);
-    qreal width = right - left;
-    qreal invheight = top - bottom;
-    qreal clip = farPlane - nearPlane;
-    m.m[0][0] = 2.0f * nearPlane / width;
+    const qreal width = right - left;
+    const qreal invheight = top - bottom;
+    const qreal clip = farPlane - nearPlane;
+    const qreal inv_width = 1 / width;
+    const qreal inv_invheight = 1 / invheight;
+    const qreal inv_clip = 1 / clip;
+    m.m[0][0] = 2.0f * nearPlane * inv_width;
     m.m[1][0] = 0.0f;
-    m.m[2][0] = (left + right) / width;
+    m.m[2][0] = (left + right) * inv_width;
     m.m[3][0] = 0.0f;
     m.m[0][1] = 0.0f;
-    m.m[1][1] = 2.0f * nearPlane / invheight;
-    m.m[2][1] = (top + bottom) / invheight;
+    m.m[1][1] = 2.0f * nearPlane * inv_invheight;
+    m.m[2][1] = (top + bottom) * inv_invheight;
     m.m[3][1] = 0.0f;
     m.m[0][2] = 0.0f;
     m.m[1][2] = 0.0f;
-    m.m[2][2] = -(nearPlane + farPlane) / clip;
-    m.m[3][2] = -2.0f * nearPlane * farPlane / clip;
+    m.m[2][2] = -(nearPlane + farPlane) * inv_clip;
+    m.m[3][2] = -2.0f * nearPlane * farPlane * inv_clip;
     m.m[0][3] = 0.0f;
     m.m[1][3] = 0.0f;
     m.m[2][3] = -1.0f;
@@ -1394,12 +1406,13 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f
 
     // Construct the projection.
     QMatrix4x4 m(1);
-    qreal radians = (angle / 2.0f) * M_PI / 180.0f;
-    qreal sine = qSin(radians);
+    const qreal radians = (angle * 0.5f) * Q_PI180;
+    const qreal sine = qSin(radians);
     if (sine == 0.0f)
         return;
-    qreal cotan = qCos(radians) / sine;
-    qreal clip = farPlane - nearPlane;
+    const qreal cotan = qCos(radians) / sine;
+    const qreal clip = farPlane - nearPlane;
+    const qreal inv_clip = 1 / clip;
     m.m[0][0] = cotan / aspect;
     m.m[1][0] = 0.0f;
     m.m[2][0] = 0.0f;
@@ -1410,8 +1423,8 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f
     m.m[3][1] = 0.0f;
     m.m[0][2] = 0.0f;
     m.m[1][2] = 0.0f;
-    m.m[2][2] = -(nearPlane + farPlane) / clip;
-    m.m[3][2] = -(2.0f * nearPlane * farPlane) / clip;
+    m.m[2][2] = -(nearPlane + farPlane) * inv_clip;
+    m.m[3][2] = -(2.0f * nearPlane * farPlane) * inv_clip;
     m.m[0][3] = 0.0f;
     m.m[1][3] = 0.0f;
     m.m[2][3] = -1.0f;
diff --git a/src/gui/math3d/qquaternion.cpp b/src/gui/math3d/qquaternion.cpp
index 626cb3c..da629e6 100644
--- a/src/gui/math3d/qquaternion.cpp
+++ b/src/gui/math3d/qquaternion.cpp
@@ -269,11 +269,12 @@ void QQuaternion::normalize()
         return;
 
     len = qSqrt(len);
+    const double inv_len = 1 / len;
 
-    xp /= len;
-    yp /= len;
-    zp /= len;
-    wp /= len;
+    xp *= inv_len;
+    yp *= inv_len;
+    zp *= inv_len;
+    wp *= inv_len;
 }
 
 /*!
@@ -357,7 +358,7 @@ QQuaternion QQuaternion::fromAxisAndAngle(const QVector3D& axis, qreal angle)
     // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56
     // We normalize the result just in case the values are close
     // to zero, as suggested in the above FAQ.
-    qreal a = (angle / 2.0f) * M_PI / 180.0f;
+    qreal a = (angle * 0.5f) * Q_PI180;
     qreal s = qSin(a);
     qreal c = qCos(a);
     QVector3D ax = axis.normalized();
@@ -375,11 +376,12 @@ QQuaternion QQuaternion::fromAxisAndAngle
 {
     qreal length = qSqrt(x * x + y * y + z * z);
     if (!qFuzzyIsNull(length - 1.0f) && !qFuzzyIsNull(length)) {
-        x /= length;
-        y /= length;
-        z /= length;
+        const qreal inv_length = 1 / length;
+        x *= inv_length;
+        y *= inv_length;
+        z *= inv_length;
     }
-    qreal a = (angle / 2.0f) * M_PI / 180.0f;
+    qreal a = (angle * 0.5f) * Q_PI180;
     qreal s = qSin(a);
     qreal c = qCos(a);
     return QQuaternion(c, x * s, y * s, z * s).normalized();
@@ -516,12 +518,13 @@ QQuaternion QQuaternion::slerp
     // then revert to simple linear interpolation.
     qreal factor1 = 1.0f - t;
     qreal factor2 = t;
-    if ((1.0f - dot) > 0.0000001) {
+    if ((1.0f - dot) > qreal(0.0000001)) {
         qreal angle = qreal(qAcos(dot));
         qreal sinOfAngle = qreal(qSin(angle));
-        if (sinOfAngle > 0.0000001) {
-            factor1 = qreal(qSin((1.0f - t) * angle)) / sinOfAngle;
-            factor2 = qreal(qSin(t * angle)) / sinOfAngle;
+        if (sinOfAngle > qreal(0.0000001)) {
+            const qreal inv_sinOfAngle = 1 / sinOfAngle;
+            factor1 = qreal(qSin((1.0f - t) * angle)) * inv_sinOfAngle;
+            factor2 = qreal(qSin(t * angle)) * inv_sinOfAngle;
         }
     }
 
diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp
index 2555a6f..a959979 100644
--- a/src/gui/math3d/qvector2d.cpp
+++ b/src/gui/math3d/qvector2d.cpp
@@ -216,9 +216,9 @@ void QVector2D::normalize()
         return;
 
     len = qSqrt(len);
-
-    xp /= len;
-    yp /= len;
+    const double inv_len = 1 / len;
+    xp *= inv_len;
+    yp *= inv_len;
 }
 
 /*!
diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp
index 9552e3a..a8cc807 100644
--- a/src/gui/math3d/qvector3d.cpp
+++ b/src/gui/math3d/qvector3d.cpp
@@ -233,10 +233,10 @@ void QVector3D::normalize()
         return;
 
     len = qSqrt(len);
-
-    xp /= len;
-    yp /= len;
-    zp /= len;
+    const double inv_len = 1 / len;
+    xp *= inv_len;
+    yp *= inv_len;
+    zp *= inv_len;
 }
 
 /*!
diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp
index 1691a6d..e4b2b82 100644
--- a/src/gui/math3d/qvector4d.cpp
+++ b/src/gui/math3d/qvector4d.cpp
@@ -285,11 +285,11 @@ void QVector4D::normalize()
         return;
 
     len = qSqrt(len);
-
-    xp /= len;
-    yp /= len;
-    zp /= len;
-    wp /= len;
+    const double inv_len = 1 / len;
+    xp *= inv_len;
+    yp *= inv_len;
+    zp *= inv_len;
+    wp *= inv_len;
 }
 
 /*!
@@ -459,7 +459,8 @@ QVector2D QVector4D::toVector2DAffine() const
 {
     if (qIsNull(wp))
         return QVector2D();
-    return QVector2D(xp / wp, yp / wp, 1);
+    const qreal inv_wp = 1 / wp;
+    return QVector2D(xp * inv_wp, yp * inv_wp, 1);
 }
 
 #endif
@@ -486,7 +487,8 @@ QVector3D QVector4D::toVector3DAffine() const
 {
     if (qIsNull(wp))
         return QVector3D();
-    return QVector3D(xp / wp, yp / wp, zp / wp, 1);
+    const qreal inv_wp = 1 / wp;
+    return QVector3D(xp * inv_wp, yp * inv_wp, zp * inv_wp, 1);
 }
 
 #endif
diff --git a/src/gui/painting/qbezier.cpp b/src/gui/painting/qbezier.cpp
index a6b4cef..c49086b 100644
--- a/src/gui/painting/qbezier.cpp
+++ b/src/gui/painting/qbezier.cpp
@@ -62,10 +62,10 @@ QT_BEGIN_NAMESPACE
 #endif
 
 #ifndef M_SQRT2
-#define M_SQRT2	1.41421356237309504880
+#define M_SQRT2	qreal(1.41421356237309504880)
 #endif
 
-#define log2(x) (qLn(x)/qLn(2.))
+#define log2(x) (qLn(qreal(x))/qLn(qreal(2.)))
 
 static inline qreal log4(qreal x)
 {
@@ -132,7 +132,7 @@ static inline void flattenBezierWithoutInflections(QBezier &bez,
 
         qreal d = qAbs(dx * (bez.y3 - bez.y2) - dy * (bez.x3 - bez.x2));
 
-        qreal t = qSqrt(4. / 3. * normalized * flatness / d);
+        qreal t = qSqrt(qreal(4.) / qreal(3.) * normalized * flatness / d);
         if (t > 1 || qFuzzyIsNull(t - (qreal)1.))
             break;
         bez.parameterSplitLeft(t, &left);
@@ -267,7 +267,7 @@ void QBezier::addToPolygonMixed(QPolygonF *polygon) const
                     qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
                 l = 1.;
             }
-            if (d < .5*l || b == beziers + 31) {
+            if (d < qreal(.5)*l || b == beziers + 31) {
                 // good enough, we pop it off and add the endpoint
                 polygon->append(QPointF(b->x4, b->y4));
                 --b;
@@ -327,8 +327,8 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse
     const qreal o2 = offset*offset;
     const qreal max_dist_line = threshold*offset*offset;
     const qreal max_dist_normal = threshold*offset;
-    const qreal spacing = 0.25;
-    for (qreal i = spacing; i < 0.99; i += spacing) {
+    const qreal spacing = qreal(0.25);
+    for (qreal i = spacing; i < qreal(0.99); i += spacing) {
         QPointF p1 = b1->pointAt(i);
         QPointF p2 = b2->pointAt(i);
         qreal d = (p1.x() - p2.x())*(p1.x() - p2.x()) + (p1.y() - p2.y())*(p1.y() - p2.y());
@@ -337,7 +337,7 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse
 
         QPointF normalPoint = b1->normalVector(i);
         qreal l = qAbs(normalPoint.x()) + qAbs(normalPoint.y());
-        if (l != 0.) {
+        if (l != qreal(0.)) {
             d = qAbs( normalPoint.x()*(p1.y() - p2.y()) - normalPoint.y()*(p1.x() - p2.x()) ) / l;
             if (d > max_dist_normal)
                 return Split;
@@ -418,14 +418,14 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr
     }
 
     QRectF b = orig->bounds();
-    if (np == 4 && b.width() < .1*offset && b.height() < .1*offset) {
+    if (np == 4 && b.width() < qreal(.1)*offset && b.height() < qreal(.1)*offset) {
         qreal l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) +
                   (orig->y1 - orig->y2)*(orig->y1 - orig->y1) *
                   (orig->x3 - orig->x4)*(orig->x3 - orig->x4) +
                   (orig->y3 - orig->y4)*(orig->y3 - orig->y4);
         qreal dot = (orig->x1 - orig->x2)*(orig->x3 - orig->x4) +
                     (orig->y1 - orig->y2)*(orig->y3 - orig->y4);
-        if (dot < 0 && dot*dot < 0.8*l)
+        if (dot < 0 && dot*dot < qreal(0.8)*l)
             // the points are close and reverse dirction. Approximate the whole
             // thing by a semi circle
             return Circle;
@@ -444,7 +444,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr
 
         QPointF normal_sum = prev_normal + next_normal;
 
-        qreal r = 1.0 + prev_normal.x() * next_normal.x()
+        qreal r = qreal(1.0) + prev_normal.x() * next_normal.x()
                   + prev_normal.y() * next_normal.y();
 
         if (qFuzzyIsNull(r)) {
@@ -468,7 +468,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr
 // This value is used to determine the length of control point vectors
 // when approximating arc segments as curves. The factor is multiplied
 // with the radius of the circle.
-#define KAPPA 0.5522847498
+#define KAPPA qreal(0.5522847498)
 
 
 static bool addCircle(const QBezier *b, qreal offset, QBezier *o)
@@ -490,32 +490,32 @@ static bool addCircle(const QBezier *b, qreal offset, QBezier *o)
     normals[1] /= -1*qSqrt(normals[1].x()*normals[1].x() + normals[1].y()*normals[1].y());
 
     qreal angles[2];
-    qreal sign = 1.;
+    qreal sign = qreal(1.);
     for (int i = 0; i < 2; ++i) {
         qreal cos_a = normals[i].x()*normals[i+1].x() + normals[i].y()*normals[i+1].y();
-        if (cos_a > 1.)
-            cos_a = 1.;
-        if (cos_a < -1.)
+        if (cos_a > qreal(1.))
+            cos_a = qreal(1.);
+        if (cos_a < qreal(-1.))
             cos_a = -1;
-        angles[i] = acos(cos_a)/Q_PI;
+        angles[i] = qAcos(cos_a)/Q_PI;
     }
 
-    if (angles[0] + angles[1] > 1.) {
+    if (angles[0] + angles[1] > qreal(1.)) {
         // more than 180 degrees
         normals[1] = -normals[1];
-        angles[0] = 1. - angles[0];
-        angles[1] = 1. - angles[1];
-        sign = -1.;
+        angles[0] = qreal(1.) - angles[0];
+        angles[1] = qreal(1.) - angles[1];
+        sign = qreal(-1.);
 
     }
 
     QPointF circle[3];
     circle[0] = QPointF(b->x1, b->y1) + normals[0]*offset;
-    circle[1] = QPointF(0.5*(b->x1 + b->x4), 0.5*(b->y1 + b->y4)) + normals[1]*offset;
+    circle[1] = QPointF(qreal(0.5)*(b->x1 + b->x4), qreal(0.5)*(b->y1 + b->y4)) + normals[1]*offset;
     circle[2] = QPointF(b->x4, b->y4) + normals[2]*offset;
 
     for (int i = 0; i < 2; ++i) {
-        qreal kappa = 2.*KAPPA * sign * offset * angles[i];
+        qreal kappa = qreal(2.)*KAPPA * sign * offset * angles[i];
 
         o->x1 = circle[i].x();
         o->y1 = circle[i].y();
@@ -695,7 +695,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
     if (deptha > 0) {
 	QBezier A[2];
         a.split(&A[0], &A[1]);
-	qreal tmid = (t0+t1)*0.5;
+	qreal tmid = (t0+t1)*qreal(0.5);
         //qDebug()<<"\t1)"<<A[0];
         //qDebug()<<"\t2)"<<A[1];
 	deptha--;
@@ -704,7 +704,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
             b.split(&B[0], &B[1]);
             //qDebug()<<"\t3)"<<B[0];
             //qDebug()<<"\t4)"<<B[1];
-	    qreal umid = (u0+u1)*0.5;
+	    qreal umid = (u0+u1)*qreal(0.5);
 	    depthb--;
 	    if (IntersectBB(A[0], B[0])) {
                 //fprintf(stderr, "\t 1 from %d\n", currentD);
@@ -756,7 +756,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
 	if (depthb > 0) {
 	    QBezier B[2];
             b.split(&B[0], &B[1]);
-	    qreal umid = (u0 + u1)*0.5;
+	    qreal umid = (u0 + u1)*qreal(0.5);
 	    depthb--;
 	    if (IntersectBB(a, B[0])) {
                 //fprintf(stderr, "\t 7 from %d\n", currentD);
@@ -783,13 +783,13 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
 	    qreal xmk = b.x1 - a.x1;
 	    qreal ymk = b.y1 - a.y1;
 	    qreal det = xnm * ylk - ynm * xlk;
-	    if (1.0 + det == 1.0) {
+	    if (qreal(1.0) + det == qreal(1.0)) {
 		return false;
             } else {
                 qreal detinv = 1.0 / det;
                 qreal rs = (xnm * ymk - ynm *xmk) * detinv;
                 qreal rt = (xlk * ymk - ylk * xmk) * detinv;
-                if ((rs < 0.0) || (rs > 1.0) || (rt < 0.0) || (rt > 1.0))
+                if ((rs < qreal(0.0)) || (rs > qreal(1.0)) || (rt < qreal(0.0)) || (rt > qreal(1.0)))
                     return false;
 
                 if (t) {
@@ -816,17 +816,17 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b,
                                 QVector<QPair<qreal, qreal> > *t)
 {
     if (IntersectBB(a, b)) {
-        QPointF la1(fabs((a.x3 - a.x2) - (a.x2 - a.x1)),
-                    fabs((a.y3 - a.y2) - (a.y2 - a.y1)));
-	QPointF la2(fabs((a.x4 - a.x3) - (a.x3 - a.x2)),
-                    fabs((a.y4 - a.y3) - (a.y3 - a.y2)));
+        QPointF la1(qFabs((a.x3 - a.x2) - (a.x2 - a.x1)),
+                    qFabs((a.y3 - a.y2) - (a.y2 - a.y1)));
+	QPointF la2(qFabs((a.x4 - a.x3) - (a.x3 - a.x2)),
+                    qFabs((a.y4 - a.y3) - (a.y3 - a.y2)));
 	QPointF la;
 	if (la1.x() > la2.x()) la.setX(la1.x()); else la.setX(la2.x());
 	if (la1.y() > la2.y()) la.setY(la1.y()); else la.setY(la2.y());
-	QPointF lb1(fabs((b.x3 - b.x2) - (b.x2 - b.x1)),
-                    fabs((b.y3 - b.y2) - (b.y2 - b.y1)));
-	QPointF lb2(fabs((b.x4 - b.x3) - (b.x3 - b.x2)),
-                    fabs((b.y4 - b.y3) - (b.y3 - b.y2)));
+	QPointF lb1(qFabs((b.x3 - b.x2) - (b.x2 - b.x1)),
+                    qFabs((b.y3 - b.y2) - (b.y2 - b.y1)));
+	QPointF lb2(qFabs((b.x4 - b.x3) - (b.x3 - b.x2)),
+                    qFabs((b.y4 - b.y3) - (b.y3 - b.y2)));
 	QPointF lb;
 	if (lb1.x() > lb2.x()) lb.setX(lb1.x()); else lb.setX(lb2.x());
 	if (lb1.y() > lb2.y()) lb.setY(lb1.y()); else lb.setY(lb2.y());
@@ -836,27 +836,27 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b,
 	else
 	    l0 = la.y();
 	int ra;
-	if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0)
+	if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0))
 	    ra = 0;
 	else
-	    ra = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0));
+	    ra = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0));
 	if (lb.x() > lb.y())
 	    l0 = lb.x();
 	else
 	    l0 = lb.y();
 	int rb;
-	if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0)
+	if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0))
 	    rb = 0;
 	else
-	    rb = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0));
+	    rb = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0));
 
         // if qreal is float then halve the number of subdivisions
         if (sizeof(qreal) == 4) {
-            ra /= 2;
-            rb /= 2;
+            ra *= qreal(0.5);
+            rb *= qreal(0.5);
         }
 
-	return RecursivelyIntersect(a, 0., 1., ra, b, 0., 1., rb, t);
+	return RecursivelyIntersect(a, qreal(0.), qreal(1.), ra, b, qreal(0.), qreal(1.), rb, t);
     }
 
     //Don't sort here because it breaks the orders of corresponding
@@ -934,7 +934,7 @@ QVector< QList<QBezier> > QBezier::splitAtIntersections(QBezier &b)
 
 qreal QBezier::length(qreal error) const
 {
-    qreal length = 0.0;
+    qreal length = qreal(0.0);
 
     addIfClose(&length, error);
 
@@ -945,7 +945,7 @@ void QBezier::addIfClose(qreal *length, qreal error) const
 {
     QBezier left, right;     /* bez poly splits */
 
-    qreal len = 0.0;        /* arc length */
+    qreal len = qreal(0.0);        /* arc length */
     qreal chord;            /* chord length */
 
     len = len + QLineF(QPointF(x1, y1),QPointF(x2, y2)).length();
@@ -988,7 +988,7 @@ qreal QBezier::tForY(qreal t0, qreal t1, qreal y) const
     qreal lt = t0;
     qreal dt;
     do {
-        qreal t = 0.5 * (t0 + t1);
+        qreal t = qreal(0.5) * (t0 + t1);
 
         qreal a, b, c, d;
         QBezier::coefficients(t, a, b, c, d);
@@ -1054,15 +1054,15 @@ int QBezier::stationaryYPoints(qreal &t0, qreal &t1) const
 qreal QBezier::tAtLength(qreal l) const
 {
     qreal len = length();
-    qreal t   = 1.0;
-    const qreal error = (qreal)0.01;
+    qreal t   = qreal(1.0);
+    const qreal error = qreal(0.01);
     if (l > len || qFuzzyCompare(l, len))
         return t;
 
-    t *= 0.5;
+    t *= qreal(0.5);
     //int iters = 0;
     //qDebug()<<"LEN is "<<l<<len;
-    qreal lastBigger = 1.;
+    qreal lastBigger = qreal(1.);
     while (1) {
         //qDebug()<<"\tt is "<<t;
         QBezier right = *this;
@@ -1073,10 +1073,10 @@ qreal QBezier::tAtLength(qreal l) const
             break;
 
         if (lLen < l) {
-            t += (lastBigger - t)*.5;
+            t += (lastBigger - t)*qreal(.5);
         } else {
             lastBigger = t;
-            t -= t*.5;
+            t -= t*qreal(.5);
         }
         //++iters;
     }
@@ -1120,7 +1120,7 @@ static inline void bindInflectionPoint(const QBezier &bez, const qreal t,
     qreal ey = 3 * (right.y2 - right.y3);
 
     qreal s4 = qAbs(6 * (ey * ax - ex * ay) / qSqrt(ex * ex + ey * ey)) + 0.00001f;
-    qreal tf = pow(qreal(9 * flatness / s4), qreal(1./3.));
+    qreal tf = qPow(qreal(9 * flatness / s4), qreal(1.)/qreal(3.));
     *tMinus = t - (1 - t) * tf;
     *tPlus  = t + (1 - t) * tf;
 }
diff --git a/src/gui/painting/qbezier_p.h b/src/gui/painting/qbezier_p.h
index 7dbd0c2..4cdb0c8 100644
--- a/src/gui/painting/qbezier_p.h
+++ b/src/gui/painting/qbezier_p.h
@@ -83,7 +83,7 @@ public:
     void addToPolygonIterative(QPolygonF *p) const;
     void addToPolygonMixed(QPolygonF *p) const;
     QRectF bounds() const;
-    qreal length(qreal error = 0.01) const;
+    qreal length(qreal error = qreal(0.01)) const;
     void addIfClose(qreal *length, qreal error) const;
 
     qreal tAtLength(qreal len) const;
@@ -122,13 +122,14 @@ public:
 
 inline QPointF QBezier::midPoint() const
 {
-    return QPointF((x1 + x4 + 3*(x2 + x3))/8., (y1 + y4 + 3*(y2 + y3))/8.);
+    const qreal inv_8 = 1 / qreal(8.);
+    return QPointF((x1 + x4 + 3*(x2 + x3))*inv_8, (y1 + y4 + 3*(y2 + y3))*inv_8);
 }
 
 inline QLineF QBezier::midTangent() const
 {
     QPointF mid = midPoint();
-    QLineF dir(QLineF(x1, y1, x2, y2).pointAt(0.5), QLineF(x3, y3, x4, y4).pointAt(0.5));
+    QLineF dir(QLineF(x1, y1, x2, y2).pointAt(qreal(0.5)), QLineF(x3, y3, x4, y4).pointAt(qreal(0.5)));
     return QLineF(mid.x() - dir.dx(), mid.y() - dir.dy(),
                   mid.x() + dir.dx(), mid.y() + dir.dy());
 }
@@ -155,13 +156,13 @@ inline QLineF QBezier::endTangent() const
 
 inline void QBezier::coefficients(qreal t, qreal &a, qreal &b, qreal &c, qreal &d)
 {
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
     b = m_t * m_t;
     c = t * t;
     d = c * t;
     a = b * m_t;
-    b *= 3. * t;
-    c *= 3. * m_t;
+    b *= qreal(3.) * t;
+    c *= qreal(3.) * m_t;
 }
 
 inline QPointF QBezier::pointAt(qreal t) const
@@ -174,7 +175,7 @@ inline QPointF QBezier::pointAt(qreal t) const
     return QPointF(a*x1 + b*x2 + c*x3 + d*x4, a*y1 + b*y2 + c*y3 + d*y4);
 #else
     // numerically more stable:
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
     qreal a = x1*m_t + x2*t;
     qreal b = x2*m_t + x3*t;
     qreal c = x3*m_t + x4*t;
@@ -193,7 +194,7 @@ inline QPointF QBezier::pointAt(qreal t) const
 
 inline QPointF QBezier::normalVector(qreal t) const
 {
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
     qreal a = m_t * m_t;
     qreal b = t * m_t;
     qreal c = t * t;
@@ -205,7 +206,7 @@ inline QPointF QBezier::derivedAt(qreal t) const
 {
     // p'(t) = 3 * (-(1-2t+t^2) * p0 + (1 - 4 * t + 3 * t^2) * p1 + (2 * t - 3 * t^2) * p2 + t^2 * p3)
 
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
 
     qreal d = t * t;
     qreal a = -m_t * m_t;
@@ -218,7 +219,7 @@ inline QPointF QBezier::derivedAt(qreal t) const
 
 inline QPointF QBezier::secondDerivedAt(qreal t) const
 {
-    qreal a = 2. - 2. * t;
+    qreal a = qreal(2.) - qreal(2.) * t;
     qreal b = -4 + 6 * t;
     qreal c = 2 - 6 * t;
     qreal d = 2 * t;
@@ -232,23 +233,23 @@ inline void QBezier::split(QBezier *firstHalf, QBezier *secondHalf) const
     Q_ASSERT(firstHalf);
     Q_ASSERT(secondHalf);
 
-    qreal c = (x2 + x3)*.5;
-    firstHalf->x2 = (x1 + x2)*.5;
-    secondHalf->x3 = (x3 + x4)*.5;
+    qreal c = (x2 + x3)*qreal(.5);
+    firstHalf->x2 = (x1 + x2)*qreal(.5);
+    secondHalf->x3 = (x3 + x4)*qreal(.5);
     firstHalf->x1 = x1;
     secondHalf->x4 = x4;
-    firstHalf->x3 = (firstHalf->x2 + c)*.5;
-    secondHalf->x2 = (secondHalf->x3 + c)*.5;
-    firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*.5;
+    firstHalf->x3 = (firstHalf->x2 + c)*qreal(.5);
+    secondHalf->x2 = (secondHalf->x3 + c)*qreal(.5);
+    firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*qreal(.5);
 
-    c = (y2 + y3)/2;
-    firstHalf->y2 = (y1 + y2)*.5;
-    secondHalf->y3 = (y3 + y4)*.5;
+    c = (y2 + y3)*qreal(.5);
+    firstHalf->y2 = (y1 + y2)*qreal(.5);
+    secondHalf->y3 = (y3 + y4)*qreal(.5);
     firstHalf->y1 = y1;
     secondHalf->y4 = y4;
-    firstHalf->y3 = (firstHalf->y2 + c)*.5;
-    secondHalf->y2 = (secondHalf->y3 + c)*.5;
-    firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*.5;
+    firstHalf->y3 = (firstHalf->y2 + c)*qreal(.5);
+    secondHalf->y2 = (secondHalf->y3 + c)*qreal(.5);
+    firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*qreal(.5);
 }
 
 inline void QBezier::parameterSplitLeft(qreal t, QBezier *left)
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
index f8dd424..76d50db 100644
--- a/src/gui/painting/qblendfunctions.cpp
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -223,8 +223,8 @@ void qt_scale_image_16bit(uchar *destPixels, int dbpl,
     int h = ty2 - ty1;
     int w = tx2 - tx1;
 
-    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
-    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
+    const int dstx = qCeil((tx1 + qreal(0.5) - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
+    const int dsty = qCeil((ty1 + qreal(0.5) - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
 
     quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;
     quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;
@@ -723,8 +723,8 @@ template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
     int h = ty2 - ty1;
     int w = tx2 - tx1;
 
-    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
-    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
+    const int dstx = qCeil((tx1 + qreal(0.5) - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
+    const int dsty = qCeil((ty1 + qreal(0.5) - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
 
     quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;
     quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;
@@ -818,8 +818,8 @@ void qt_transform_image_rasterize(DestT *destPixels, int dbpl,
     qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y);
     int dx_l = int(leftSlope * 0x10000);
     int dx_r = int(rightSlope * 0x10000);
-    int x_l = int((topLeft.x + (0.5 + fromY - topLeft.y) * leftSlope + 0.5) * 0x10000);
-    int x_r = int((topRight.x + (0.5 + fromY - topRight.y) * rightSlope + 0.5) * 0x10000);
+    int x_l = int((topLeft.x + (qreal(0.5) + fromY - topLeft.y) * leftSlope + qreal(0.5)) * 0x10000);
+    int x_r = int((topRight.x + (qreal(0.5) + fromY - topRight.y) * rightSlope + qreal(0.5)) * 0x10000);
 
     int fromX, toX, x1, x2, u, v, i, ii;
     DestT *line;
@@ -996,7 +996,7 @@ void qt_transform_image(DestT *destPixels, int dbpl,
     if (det == 0)
         return;
 
-    qreal invDet = 1.0 / det;
+    qreal invDet = qreal(1.0) / det;
     qreal m11, m12, m21, m22, mdx, mdy;
 
     m11 = (u.u * w.y - u.y * w.u) * invDet;
@@ -1010,8 +1010,8 @@ void qt_transform_image(DestT *destPixels, int dbpl,
     int dvdx = int(m21 * 0x10000);
     int dudy = int(m12 * 0x10000);
     int dvdy = int(m22 * 0x10000);
-    int u0 = qCeil((0.5 * m11 + 0.5 * m12 + mdx) * 0x10000) - 1;
-    int v0 = qCeil((0.5 * m21 + 0.5 * m22 + mdy) * 0x10000) - 1;
+    int u0 = qCeil((qreal(0.5) * m11 + qreal(0.5) * m12 + mdx) * 0x10000) - 1;
+    int v0 = qCeil((qreal(0.5) * m21 + qreal(0.5) * m22 + mdy) * 0x10000) - 1;
 
     int x1 = qFloor(sourceRect.left());
     int y1 = qFloor(sourceRect.top());
diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp
index cbfbba6..6982f22 100644
--- a/src/gui/painting/qbrush.cpp
+++ b/src/gui/painting/qbrush.cpp
@@ -1752,7 +1752,7 @@ static QPointF qt_radial_gradient_adapt_focal_point(const QPointF &center,
     // We have a one pixel buffer zone to avoid numerical instability on the
     // circle border
     //### this is hacky because technically we should adjust based on current matrix
-    const qreal compensated_radius = radius - radius * 0.001;
+    const qreal compensated_radius = radius - radius * qreal(0.001);
     QLineF line(center, focalPoint);
     if (line.length() > (compensated_radius))
         line.setLength(compensated_radius);
diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp
index 4da993b..acbad3e 100644
--- a/src/gui/painting/qcolor.cpp
+++ b/src/gui/painting/qcolor.cpp
@@ -604,12 +604,13 @@ void QColor::getHsvF(qreal *h, qreal *s, qreal *v, qreal *a) const
         return;
     }
 
-    *h = ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0;
-    *s = ct.ahsv.saturation / qreal(USHRT_MAX);
-    *v = ct.ahsv.value / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    *h = ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0);
+    *s = ct.ahsv.saturation * inv_USHRT_MAX;
+    *v = ct.ahsv.value * inv_USHRT_MAX;
 
     if (a)
-        *a = ct.ahsv.alpha / qreal(USHRT_MAX);
+        *a = ct.ahsv.alpha * inv_USHRT_MAX;
 }
 
 /*!
@@ -715,12 +716,13 @@ void QColor::getHslF(qreal *h, qreal *s, qreal *l, qreal *a) const
         return;
     }
 
-    *h = ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0;
-    *s = ct.ahsl.saturation / qreal(USHRT_MAX);
-    *l = ct.ahsl.lightness / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    *h = ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0);
+    *s = ct.ahsl.saturation * inv_USHRT_MAX;
+    *l = ct.ahsl.lightness * inv_USHRT_MAX;
 
     if (a)
-        *a = ct.ahsl.alpha / qreal(USHRT_MAX);
+        *a = ct.ahsl.alpha * inv_USHRT_MAX;
 }
 
 /*!
@@ -1300,7 +1302,7 @@ qreal QColor::hsvHueF() const
 {
     if (cspec != Invalid && cspec != Hsv)
         return toHsv().hueF();
-    return ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0;
+    return ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0);
 }
 
 /*!
@@ -1396,7 +1398,7 @@ qreal QColor::hslHueF() const
 {
     if (cspec != Invalid && cspec != Hsl)
         return toHsl().hslHueF();
-    return ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0;
+    return ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0);
 }
 
 /*!
@@ -1547,6 +1549,8 @@ QColor QColor::toRgb() const
     color.ct.argb.alpha = ct.argb.alpha;
     color.ct.argb.pad = 0;
 
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+
     switch (cspec) {
     case Hsv:
         {
@@ -1557,15 +1561,15 @@ QColor QColor::toRgb() const
             }
 
             // chromatic case
-            const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / 6000.;
-            const qreal s = ct.ahsv.saturation / qreal(USHRT_MAX);
-            const qreal v = ct.ahsv.value / qreal(USHRT_MAX);
+            const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / qreal(6000.);
+            const qreal s = ct.ahsv.saturation * inv_USHRT_MAX;
+            const qreal v = ct.ahsv.value * inv_USHRT_MAX;
             const int i = int(h);
             const qreal f = h - i;
-            const qreal p = v * (1.0 - s);
+            const qreal p = v * (qreal(1.0) - s);
 
             if (i & 1) {
-                const qreal q = v * (1.0 - (s * f));
+                const qreal q = v * (qreal(1.0) - (s * f));
 
                 switch (i) {
                 case 1:
@@ -1585,7 +1589,7 @@ QColor QColor::toRgb() const
                     break;
                 }
             } else {
-                const qreal t = v * (1.0 - (s * (1.0 - f)));
+                const qreal t = v * (qreal(1.0) - (s * (qreal(1.0) - f)));
 
                 switch (i) {
                 case 0:
@@ -1617,9 +1621,9 @@ QColor QColor::toRgb() const
                 color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = 0;
             } else {
                 // chromatic case
-                const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / 36000.;
-                const qreal s = ct.ahsl.saturation / qreal(USHRT_MAX);
-                const qreal l = ct.ahsl.lightness / qreal(USHRT_MAX);
+                const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / qreal(36000.);
+                const qreal s = ct.ahsl.saturation * inv_USHRT_MAX;
+                const qreal l = ct.ahsl.lightness * inv_USHRT_MAX;
 
                 qreal temp2;
                 if (l < qreal(0.5))
@@ -1656,14 +1660,14 @@ QColor QColor::toRgb() const
         }
     case Cmyk:
         {
-            const qreal c = ct.acmyk.cyan / qreal(USHRT_MAX);
-            const qreal m = ct.acmyk.magenta / qreal(USHRT_MAX);
-            const qreal y = ct.acmyk.yellow / qreal(USHRT_MAX);
-            const qreal k = ct.acmyk.black / qreal(USHRT_MAX);
-
-            color.ct.argb.red   = qRound((1.0 - (c * (1.0 - k) + k)) * USHRT_MAX);
-            color.ct.argb.green = qRound((1.0 - (m * (1.0 - k) + k)) * USHRT_MAX);
-            color.ct.argb.blue  = qRound((1.0 - (y * (1.0 - k) + k)) * USHRT_MAX);
+            const qreal c = ct.acmyk.cyan * inv_USHRT_MAX;
+            const qreal m = ct.acmyk.magenta * inv_USHRT_MAX;
+            const qreal y = ct.acmyk.yellow * inv_USHRT_MAX;
+            const qreal k = ct.acmyk.black * inv_USHRT_MAX;
+
+            color.ct.argb.red   = qRound((qreal(1.0) - (c * (qreal(1.0) - k) + k)) * USHRT_MAX);
+            color.ct.argb.green = qRound((qreal(1.0) - (m * (qreal(1.0) - k) + k)) * USHRT_MAX);
+            color.ct.argb.blue  = qRound((qreal(1.0) - (y * (qreal(1.0) - k) + k)) * USHRT_MAX);
             break;
         }
     default:
@@ -1697,9 +1701,10 @@ QColor QColor::toHsv() const
     color.ct.ahsv.alpha = ct.argb.alpha;
     color.ct.ahsv.pad = 0;
 
-    const qreal r = ct.argb.red   / qreal(USHRT_MAX);
-    const qreal g = ct.argb.green / qreal(USHRT_MAX);
-    const qreal b = ct.argb.blue  / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    const qreal r = ct.argb.red   * inv_USHRT_MAX;
+    const qreal g = ct.argb.green * inv_USHRT_MAX;
+    const qreal b = ct.argb.blue  * inv_USHRT_MAX;
     const qreal max = Q_MAX_3(r, g, b);
     const qreal min = Q_MIN_3(r, g, b);
     const qreal delta = max - min;
@@ -1715,15 +1720,15 @@ QColor QColor::toHsv() const
         if (qFuzzyCompare(r, max)) {
             hue = ((g - b) /delta);
         } else if (qFuzzyCompare(g, max)) {
-            hue = (2.0 + (b - r) / delta);
+            hue = (qreal(2.0) + (b - r) / delta);
         } else if (qFuzzyCompare(b, max)) {
-            hue = (4.0 + (r - g) / delta);
+            hue = (qreal(4.0) + (r - g) / delta);
         } else {
             Q_ASSERT_X(false, "QColor::toHsv", "internal error");
         }
-        hue *= 60.0;
-        if (hue < 0.0)
-            hue += 360.0;
+        hue *= qreal(60.0);
+        if (hue < qreal(0.0))
+            hue += qreal(360.0);
         color.ct.ahsv.hue = qRound(hue * 100);
     }
 
@@ -1804,9 +1809,10 @@ QColor QColor::toCmyk() const
     color.ct.acmyk.alpha = ct.argb.alpha;
 
     // rgb -> cmy
-    const qreal r = ct.argb.red   / qreal(USHRT_MAX);
-    const qreal g = ct.argb.green / qreal(USHRT_MAX);
-    const qreal b = ct.argb.blue  / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    const qreal r = ct.argb.red   * inv_USHRT_MAX;
+    const qreal g = ct.argb.green * inv_USHRT_MAX;
+    const qreal b = ct.argb.blue  * inv_USHRT_MAX;
     qreal c = 1.0 - r;
     qreal m = 1.0 - g;
     qreal y = 1.0 - b;
@@ -1815,9 +1821,10 @@ QColor QColor::toCmyk() const
     const qreal k = qMin(c, qMin(m, y));
 
     if (!qFuzzyIsNull(k - 1)) {
-        c = (c - k) / (1.0 - k);
-        m = (m - k) / (1.0 - k);
-        y = (y - k) / (1.0 - k);
+        const qreal div_by_one_minus_k = 1 / (qreal(1.0) - k); 
+        c = (c - k) * div_by_one_minus_k;
+        m = (m - k) * div_by_one_minus_k;
+        y = (y - k) * div_by_one_minus_k;
     }
 
     color.ct.acmyk.cyan    = qRound(c * USHRT_MAX);
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index 41602a1..b9f439e 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -565,8 +565,8 @@ const uint * QT_FASTCALL fetchTransformed(uint *buffer, const Operator *, const
     int image_width = data->texture.width;
     int image_height = data->texture.height;
 
-    const qreal cx = x + 0.5;
-    const qreal cy = y + 0.5;
+    const qreal cx = x + qreal(0.5);
+    const qreal cy = y + qreal(0.5);
 
     const uint *end = buffer + length;
     uint *b = buffer;
@@ -670,8 +670,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *
     int image_width = data->texture.width;
     int image_height = data->texture.height;
 
-    const qreal cx = x + 0.5;
-    const qreal cy = y + 0.5;
+    const qreal cx = x + qreal(0.5);
+    const qreal cy = y + qreal(0.5);
 
     const uint *end = buffer + length;
     uint *b = buffer;
@@ -747,8 +747,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *
 
         while (b < end) {
             const qreal iw = fw == 0 ? 1 : 1 / fw;
-            const qreal px = fx * iw - 0.5;
-            const qreal py = fy * iw - 0.5;
+            const qreal px = fx * iw - qreal(0.5);
+            const qreal py = fy * iw - qreal(0.5);
 
             int x1 = int(px) - (px < 0);
             int x2 = x1 + 1;
@@ -927,7 +927,7 @@ static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = {
 
 static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
 {
-    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + 0.5);
+    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
 
   // calculate the actual offset.
     if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
@@ -1008,8 +1008,8 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator
     if (op->linear.l == 0) {
         t = inc = 0;
     } else {
-        rx = data->m21 * (y + 0.5) + data->m11 * (x + 0.5) + data->dx;
-        ry = data->m22 * (y + 0.5) + data->m12 * (x + 0.5) + data->dy;
+        rx = data->m21 * (y + qreal(0.5)) + data->m11 * (x + qreal(0.5)) + data->dx;
+        ry = data->m22 * (y + qreal(0.5)) + data->m12 * (x + qreal(0.5)) + data->dy;
         t = op->linear.dx*rx + op->linear.dy*ry + op->linear.off;
         inc = op->linear.dx * data->m11 + op->linear.dy * data->m12;
         affine = !data->m13 && !data->m23;
@@ -1045,7 +1045,7 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator
             }
         }
     } else { // fall back to float math here as well
-        qreal rw = data->m23 * (y + 0.5) + data->m13 * (x + 0.5) + data->m33;
+        qreal rw = data->m23 * (y + qreal(0.5)) + data->m13 * (x + qreal(0.5)) + data->m33;
         while (buffer < end) {
             qreal x = rx/rw;
             qreal y = ry/rw;
@@ -1092,10 +1092,10 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator
                                                     int y, int x, int length)
 {
     const uint *b = buffer;
-    qreal rx = data->m21 * (y + 0.5)
-               + data->dx + data->m11 * (x + 0.5);
-    qreal ry = data->m22 * (y + 0.5)
-               + data->dy + data->m12 * (x + 0.5);
+    qreal rx = data->m21 * (y + qreal(0.5))
+               + data->dx + data->m11 * (x + qreal(0.5));
+    qreal ry = data->m22 * (y + qreal(0.5))
+               + data->dy + data->m12 * (x + qreal(0.5));
     bool affine = !data->m13 && !data->m23;
     //qreal r  = data->gradient.radial.radius;
 
@@ -1141,8 +1141,8 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator
             ++buffer;
         }
     } else {
-        qreal rw = data->m23 * (y + 0.5)
-                   + data->m33 + data->m13 * (x + 0.5);
+        qreal rw = data->m23 * (y + qreal(0.5))
+                   + data->m33 + data->m13 * (x + qreal(0.5));
         if (!rw)
             rw = 1;
         while (buffer < end) {
@@ -1171,10 +1171,10 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato
                                                      int y, int x, int length)
 {
     const uint *b = buffer;
-    qreal rx = data->m21 * (y + 0.5)
-               + data->dx + data->m11 * (x + 0.5);
-    qreal ry = data->m22 * (y + 0.5)
-               + data->dy + data->m12 * (x + 0.5);
+    qreal rx = data->m21 * (y + qreal(0.5))
+               + data->dx + data->m11 * (x + qreal(0.5));
+    qreal ry = data->m22 * (y + qreal(0.5))
+               + data->dy + data->m12 * (x + qreal(0.5));
     bool affine = !data->m13 && !data->m23;
 
     const uint *end = buffer + length;
@@ -1182,25 +1182,25 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato
         rx -= data->gradient.conical.center.x;
         ry -= data->gradient.conical.center.y;
         while (buffer < end) {
-            qreal angle = atan2(ry, rx) + data->gradient.conical.angle;
+            qreal angle = qAtan2(ry, rx) + data->gradient.conical.angle;
 
-            *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / (2*Q_PI));
+            *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / Q_2PI);
 
             rx += data->m11;
             ry += data->m12;
             ++buffer;
         }
     } else {
-        qreal rw = data->m23 * (y + 0.5)
-                   + data->m33 + data->m13 * (x + 0.5);
+        qreal rw = data->m23 * (y + qreal(0.5))
+                   + data->m33 + data->m13 * (x + qreal(0.5));
         if (!rw)
             rw = 1;
         while (buffer < end) {
-            qreal angle = atan2(ry/rw - data->gradient.conical.center.x,
+            qreal angle = qAtan2(ry/rw - data->gradient.conical.center.x,
                                 rx/rw - data->gradient.conical.center.y)
                           + data->gradient.conical.angle;
 
-            *buffer = qt_gradient_pixel(&data->gradient, 1. - angle / (2*Q_PI));
+            *buffer = qt_gradient_pixel(&data->gradient, qreal(1.) - angle / Q_2PI);
 
             rx += data->m11;
             ry += data->m12;
@@ -5168,8 +5168,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale) - half_point;
@@ -5243,8 +5243,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -5258,8 +5258,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const
                 uint *b = buffer;
                 while (b < end) {
                     const qreal iw = w == 0 ? 1 : 1 / w;
-                    const qreal px = x * iw - 0.5;
-                    const qreal py = y * iw - 0.5;
+                    const qreal px = x * iw - qreal(0.5);
+                    const qreal py = y * iw - qreal(0.5);
 
                     int x1 = int(px) - (px < 0);
                     int x2 = x1 + 1;
@@ -5670,8 +5670,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count,
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale) - half_point;
@@ -5753,8 +5753,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count,
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -5768,8 +5768,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count,
                 uint *b = buffer;
                 while (b < end) {
                     const qreal iw = w == 0 ? 1 : 1 / w;
-                    const qreal px = x * iw - 0.5;
-                    const qreal py = y * iw - 0.5;
+                    const qreal px = x * iw - qreal(0.5);
+                    const qreal py = y * iw - qreal(0.5);
 
                     int x1 = int(px) - (px < 0);
                     int x2 = x1 + 1;
@@ -5861,8 +5861,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale);
@@ -5909,8 +5909,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -6261,8 +6261,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale);
@@ -6313,8 +6313,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -6998,7 +6998,7 @@ static void qt_gradient_quint32(int count, const QSpan *spans, void *userData)
          */
         const int gss = GRADIENT_STOPTABLE_SIZE - 1;
         int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
-        int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+        int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE));
 
         while (count--) {
             int y = spans->y;
@@ -7046,7 +7046,7 @@ static void qt_gradient_quint16(int count, const QSpan *spans, void *userData)
          */
         const int gss = GRADIENT_STOPTABLE_SIZE - 1;
         int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
-        int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+        int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE));
 
         uint oldColor = data->solid.color;
         while (count--) {
@@ -7125,13 +7125,13 @@ void qt_build_pow_tables() {
 #ifdef Q_WS_MAC
     // decided by testing a few things on an iMac, should probably get this from the
     // system...
-    smoothing = 2.0;
+    smoothing = qreal(2.0);
 #endif
 
 #ifdef Q_WS_WIN
     int winSmooth;
     if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0))
-        smoothing = winSmooth / 1000.0;
+        smoothing = winSmooth / qreal(1000.0);
 #endif
 
 #ifdef Q_WS_X11
@@ -7141,18 +7141,19 @@ void qt_build_pow_tables() {
         qt_pow_rgb_invgamma[i] = uchar(i);
     }
 #else
+    const qreal inv_255 = 1 / qreal(255.0);
     for (int i=0; i<256; ++i) {
-        qt_pow_rgb_gamma[i] = uchar(qRound(pow(i / qreal(255.0), smoothing) * 255));
-        qt_pow_rgb_invgamma[i] = uchar(qRound(pow(i / qreal(255.), 1 / smoothing) * 255));
+        qt_pow_rgb_gamma[i] = uchar(qRound(qPow(i * inv_255, smoothing) * 255));
+        qt_pow_rgb_invgamma[i] = uchar(qRound(qPow(i * inv_255, 1 / smoothing) * 255));
     }
 #endif
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
-    const qreal gray_gamma = 2.31;
+    const qreal gray_gamma = qreal(2.31);
     for (int i=0; i<256; ++i)
-        qt_pow_gamma[i] = uint(qRound(pow(i / qreal(255.), gray_gamma) * 2047));
+        qt_pow_gamma[i] = uint(qRound(qPow(i / qreal(255.), gray_gamma) * 2047));
     for (int i=0; i<2048; ++i)
-        qt_pow_invgamma[i] = uchar(qRound(pow(i / 2047.0, 1 / gray_gamma) * 255));
+        qt_pow_invgamma[i] = uchar(qRound(qPow(i / qreal(2047.0), 1 / gray_gamma) * 255));
 #endif
 }
 
diff --git a/src/gui/painting/qdrawutil.cpp b/src/gui/painting/qdrawutil.cpp
index 1182b9a..be9061f 100644
--- a/src/gui/painting/qdrawutil.cpp
+++ b/src/gui/painting/qdrawutil.cpp
@@ -1180,46 +1180,48 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
     for (int i = 2; i < rows - 1; ++i)
         yTarget[i] = yTarget[i - 1] + dy;
 
+    const qreal inv_d_source_width = 1 / (qreal)d.source.width();
+	const qreal inv_d_source_height = 1 / (qreal)d.source.height();
     // corners
     if (targetMargins.top() > 0 && targetMargins.left() > 0 && sourceMargins.top() > 0 && sourceMargins.left() > 0) { // top left
         d.point.setX(0.5 * (xTarget[1] + xTarget[0]));
         d.point.setY(0.5 * (yTarget[1] + yTarget[0]));
         d.source = QRectF(sourceRect.left(), sourceRect.top(), sourceMargins.left(), sourceMargins.top());
-        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width();
-        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueTopLeft)
             opaqueData.append(d);
         else
             translucentData.append(d);
     }
     if (targetMargins.top() > 0 && targetMargins.right() > 0 && sourceMargins.top() > 0 && sourceMargins.right() > 0) { // top right
-        d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1]));
-        d.point.setY(0.5 * (yTarget[1] + yTarget[0]));
+        d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1]));
+        d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0]));
         d.source = QRectF(sourceCenterRight, sourceRect.top(), sourceMargins.right(), sourceMargins.top());
-        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width();
-        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueTopRight)
             opaqueData.append(d);
         else
             translucentData.append(d);
     }
     if (targetMargins.bottom() > 0 && targetMargins.left() > 0 && sourceMargins.bottom() > 0 && sourceMargins.left() > 0) { // bottom left
-        d.point.setX(0.5 * (xTarget[1] + xTarget[0]));
-        d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0]));
+        d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1]));
         d.source = QRectF(sourceRect.left(), sourceCenterBottom, sourceMargins.left(), sourceMargins.bottom());
-        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width();
-        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueBottomLeft)
             opaqueData.append(d);
         else
             translucentData.append(d);
     }
     if (targetMargins.bottom() > 0 && targetMargins.right() > 0 && sourceMargins.bottom() > 0 && sourceMargins.right() > 0) { // bottom right
-        d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1]));
-        d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1]));
+        d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1]));
         d.source = QRectF(sourceCenterRight, sourceCenterBottom, sourceMargins.right(), sourceMargins.bottom());
-        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width();
-        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueBottomRight)
             opaqueData.append(d);
         else
@@ -1231,11 +1233,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.top() > 0 && sourceMargins.top() > 0) { // top
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueTop ? opaqueData : translucentData;
             d.source = QRectF(sourceCenterLeft, sourceRect.top(), sourceCenterWidth, sourceMargins.top());
-            d.point.setY(0.5 * (yTarget[1] + yTarget[0]));
-            d.scaleX = dx / d.source.width();
-            d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height();
+            d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0]));
+            d.scaleX = dx * inv_d_source_width;
+            d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height;
             for (int i = 1; i < columns - 1; ++i) {
-                d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i]));
+                d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i]));
                 data.append(d);
             }
             if (rules.horizontal == Qt::RepeatTile)
@@ -1244,11 +1246,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.bottom() > 0 && sourceMargins.bottom() > 0) { // bottom
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueBottom ? opaqueData : translucentData;
             d.source = QRectF(sourceCenterLeft, sourceCenterBottom, sourceCenterWidth, sourceMargins.bottom());;
-            d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1]));
-            d.scaleX = dx / d.source.width();
-            d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height();
+            d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1]));
+            d.scaleX = dx * inv_d_source_width;
+            d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height;
             for (int i = 1; i < columns - 1; ++i) {
-                d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i]));
+                d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i]));
                 data.append(d);
             }
             if (rules.horizontal == Qt::RepeatTile)
@@ -1261,11 +1263,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.left() > 0 && sourceMargins.left() > 0) { // left
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueLeft ? opaqueData : translucentData;
             d.source = QRectF(sourceRect.left(), sourceCenterTop, sourceMargins.left(), sourceCenterHeight);
-            d.point.setX(0.5 * (xTarget[1] + xTarget[0]));
-            d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width();
-            d.scaleY = dy / d.source.height();
+            d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0]));
+            d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width;
+            d.scaleY = dy * inv_d_source_height;
             for (int i = 1; i < rows - 1; ++i) {
-                d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i]));
+                d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i]));
                 data.append(d);
             }
             if (rules.vertical == Qt::RepeatTile)
@@ -1274,11 +1276,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.right() > 0 && sourceMargins.right() > 0) { // right
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueRight ? opaqueData : translucentData;
             d.source = QRectF(sourceCenterRight, sourceCenterTop, sourceMargins.right(), sourceCenterHeight);
-            d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1]));
-            d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width();
-            d.scaleY = dy / d.source.height();
+            d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1]));
+            d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width;
+            d.scaleY = dy * inv_d_source_height;
             for (int i = 1; i < rows - 1; ++i) {
-                d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i]));
+                d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i]));
                 data.append(d);
             }
             if (rules.vertical == Qt::RepeatTile)
@@ -1290,16 +1292,16 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
     if (targetCenterWidth > 0 && targetCenterHeight > 0 && sourceCenterWidth > 0 && sourceCenterHeight > 0) {
         QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueCenter ? opaqueData : translucentData;
         d.source = QRectF(sourceCenterLeft, sourceCenterTop, sourceCenterWidth, sourceCenterHeight);
-        d.scaleX = dx / d.source.width();
-        d.scaleY = dy / d.source.height();
+        d.scaleX = dx * inv_d_source_width;
+        d.scaleY = dy * inv_d_source_height;
 
         qreal repeatWidth = (xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX;
         qreal repeatHeight = (yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY;
 
         for (int j = 1; j < rows - 1; ++j) {
-            d.point.setY(0.5 * (yTarget[j + 1] + yTarget[j]));
+            d.point.setY(qreal(0.5) * (yTarget[j + 1] + yTarget[j]));
             for (int i = 1; i < columns - 1; ++i) {
-                d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i]));
+                d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i]));
                 data.append(d);
             }
             if (rules.horizontal == Qt::RepeatTile)
diff --git a/src/gui/painting/qmath_p.h b/src/gui/painting/qmath_p.h
index f4a3982..53ed8ab 100644
--- a/src/gui/painting/qmath_p.h
+++ b/src/gui/painting/qmath_p.h
@@ -54,13 +54,10 @@
 //
 
 #include <math.h>
+#include <private/qnumeric_p.h>
 
 QT_BEGIN_NAMESPACE
 
-static const qreal Q_PI   = qreal(3.14159265358979323846);   // pi
-static const qreal Q_2PI  = qreal(6.28318530717958647693);   // 2*pi
-static const qreal Q_PI2  = qreal(1.57079632679489661923);   // pi/2
-
 QT_END_NAMESPACE
 
 #endif // QMATH_P_H
diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp
index 6b9d77c..a323a43 100644
--- a/src/gui/painting/qpaintbuffer.cpp
+++ b/src/gui/painting/qpaintbuffer.cpp
@@ -424,7 +424,7 @@ void QPaintBufferEngine::penChanged()
             QPointF transformedWidth(penWidth, penWidth);
             if (!pen.isCosmetic())
                 transformedWidth = painter()->transform().map(transformedWidth);
-            buffer->penWidthAdjustment = transformedWidth.x() / 2.0;
+            buffer->penWidthAdjustment = transformedWidth.x() * qreal(0.5);
         }
     }
     buffer->addCommand(QPaintBufferPrivate::Cmd_SetPen, pen);
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 8d0b961..e3c4fe5 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -126,7 +126,7 @@ void dumpClip(int width, int height, const QClipData *clip);
 #define int_dim(pos, dim) (int(pos+dim) - int(pos))
 
 // use the same rounding as in qrasterizer.cpp (6 bit fixed point)
-static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
+static const qreal aliasedCoordinateDelta = qreal(0.5) - qreal(0.015625);
 
 #ifdef Q_WS_WIN
 extern bool qt_cleartype_enabled;
@@ -1743,8 +1743,8 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
             if (lines[i].p1() == lines[i].p2()) {
                 if (s->lastPen.capStyle() != Qt::FlatCap) {
                     QPointF p = lines[i].p1();
-                    QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()),
-                                                       QPointF(p.x() + width*0.5, p.y())));
+                    QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*qreal(0.5), p.y()),
+                                                       QPointF(p.x() + width*qreal(0.5), p.y())));
                     d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1);
                 }
                 continue;
@@ -1958,8 +1958,9 @@ static bool splitPolygon(const QPointF *points, int pointCount, QVector<QPointF>
     QVector<const QPointF *> sorted;
     sorted.reserve(pointCount);
 
-    upper->reserve(pointCount * 3 / 4);
-    lower->reserve(pointCount * 3 / 4);
+    const qreal three_quarters = qreal(3) / qreal(4);
+    upper->reserve(pointCount * three_quarters);
+    lower->reserve(pointCount * three_quarters);
 
     for (int i = 0; i < pointCount; ++i)
         sorted << points + i;
@@ -2336,13 +2337,13 @@ void QRasterPaintEngine::strokePolygonCosmetic(const QPoint *points, int pointCo
 
         int x1 = points[pointCount-1].x() * m11 + dx;
         int y1 = points[pointCount-1].y() * m22 + dy;
-        qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + 1.;
+        qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + qreal(1.);
         w = 1/w;
         x1 = int(x1*w);
         y1 = int(y1*w);
         int x2 = points[0].x() * m11 + dx;
         int y2 = points[0].y() * m22 + dy;
-        w = m13*points[0].x() + m23*points[0].y() + 1.;
+        w = m13*points[0].x() + m23*points[0].y() + qreal(1.);
         w = 1/w;
         x2 = int(x2 * w);
         y2 = int(y2 * w);
@@ -4867,7 +4868,7 @@ void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint
     uint next_color;
 
     qreal incr = 1 / qreal(size); // the double increment.
-    qreal dpos = 1.5 * incr; // current position in gradient stop list (0 to 1)
+    qreal dpos = qreal(1.5) * incr; // current position in gradient stop list (0 to 1)
 
      // Up to first point
     colorTable[pos++] = PREMUL(current_color);
@@ -5041,7 +5042,7 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode
             QPointF center = g->center();
             conicalData.center.x = center.x();
             conicalData.center.y = center.y();
-            conicalData.angle = g->angle() * 2 * Q_PI / 360.0;
+            conicalData.angle = g->angle() * Q_2PI / qreal(360.0);
         }
         break;
 
@@ -5140,7 +5141,8 @@ void QSpanData::setupMatrix(const QTransform &matrix, int bilin)
 {
     QTransform delta;
     // make sure we round off correctly in qdrawhelper.cpp
-    delta.translate(1.0 / 65536, 1.0 / 65536);
+    const qreal inv_65536 = qreal(1.0) / 65536;
+    delta.translate(inv_65536, inv_65536);
 
     QTransform inv = (delta * matrix).inverted();
     m11 = inv.m11();
@@ -6049,9 +6051,9 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,
     const QFixed b = QFixed(rect.height()) >> 1;
     QFixed d = b*b - (a*a*b) + ((a*a) >> 2);
 #else
-    const qreal a = qreal(rect.width()) / 2;
-    const qreal b = qreal(rect.height()) / 2;
-    qreal d = b*b - (a*a*b) + 0.25*a*a;
+    const qreal a = qreal(rect.width()) * qreal(0.5);
+    const qreal b = qreal(rect.height()) * qreal(0.5);
+    qreal d = b*b - (a*a*b) + qreal(0.25)*a*a;
 #endif
 
     int x = 0;
@@ -6079,7 +6081,7 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,
     d = b*b*(x + (QFixed(1) >> 1))*(x + (QFixed(1) >> 1))
         + a*a*((y - 1)*(y - 1) - b*b);
 #else
-    d = b*b*(x + 0.5)*(x + 0.5) + a*a*((y - 1)*(y - 1) - b*b);
+    d = b*b*(x + qreal(0.5))*(x + qreal(0.5)) + a*a*(qreal(y - 1)*qreal(y - 1) - b*b);
 #endif
     const int miny = rect.height() & 0x1;
     while (y > miny) {
@@ -6150,4 +6152,4 @@ void dumpClip(int width, int height, const QClipData *clip)
 #endif
 
 
-QT_END_NAMESPACE
+QT_END_NAMESPACE
\ No newline at end of file
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 9e21182..b3d7f08 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -727,8 +727,9 @@ void QPaintEngineEx::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yR
     qreal y2 = rect.bottom();
 
     if (mode == Qt::RelativeSize) {
-        xRadius = xRadius * rect.width() / 200.;
-        yRadius = yRadius * rect.height() / 200.;
+        const qreal inv_200 = 1 / qreal(200.);
+        xRadius = xRadius * rect.width() * inv_200;
+        yRadius = yRadius * rect.height() * inv_200;
     }
 
     xRadius = qMin(xRadius, rect.width() / 2);
@@ -842,7 +843,7 @@ void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount)
             for (int i=0; i<count; ++i) {
                 pts[++oset] = points[i].x();
                 pts[++oset] = points[i].y();
-                pts[++oset] = points[i].x() + 0.001;
+                pts[++oset] = points[i].x() + qreal(0.001);
                 pts[++oset] = points[i].y();
             }
             QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
@@ -852,7 +853,7 @@ void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount)
         }
     } else {
         for (int i=0; i<pointCount; ++i) {
-            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + 0.001, points[i].y() };
+            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + qreal(0.001), points[i].y() };
             QVectorPath path(pts, 2, 0);
             stroke(path, pen);
         }
@@ -873,7 +874,7 @@ void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount)
             for (int i=0; i<count; ++i) {
                 pts[++oset] = points[i].x();
                 pts[++oset] = points[i].y();
-                pts[++oset] = points[i].x() + 0.001;
+                pts[++oset] = points[i].x() + qreal(0.001);
                 pts[++oset] = points[i].y();
             }
             QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
@@ -883,7 +884,7 @@ void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount)
         }
     } else {
         for (int i=0; i<pointCount; ++i) {
-            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + 0.001, points[i].y() };
+            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + qreal(0.001), points[i].y() };
             QVectorPath path(pts, 2, 0);
             stroke(path, pen);
         }
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 09a4563..0cbdfbd 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -383,8 +383,8 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio
                 QPainterPath stroke = stroker.createStroke(originalPath);
                 strokeBounds = (stroke * state->matrix).boundingRect();
             } else {
-                strokeOffsetX = qAbs(penWidth * state->matrix.m11() / 2.0);
-                strokeOffsetY = qAbs(penWidth * state->matrix.m22() / 2.0);
+                strokeOffsetX = qAbs(penWidth * state->matrix.m11() * qreal(0.5));
+                strokeOffsetY = qAbs(penWidth * state->matrix.m22() * qreal(0.5));
             }
         }
     }
@@ -467,7 +467,7 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio
         pt.end();
         p.resetTransform();
         p.setCompositionMode(QPainter::CompositionMode_SourceAtop);
-        p.setOpacity(0.5);
+        p.setOpacity(qreal(0.5));
         p.fillRect(0, 0, image.width(), image.height(), QBrush(block));
     }
 #endif
@@ -3565,7 +3565,7 @@ void QPainter::drawPoints(const QPointF *points, int pointCount)
         QPainterPath path;
         for (int i=0; i<pointCount; ++i) {
             path.moveTo(points[i].x(), points[i].y());
-            path.lineTo(points[i].x() + 0.0001, points[i].y());
+            path.lineTo(points[i].x() + qreal(0.0001), points[i].y());
         }
         d->draw_helper(path, QPainterPrivate::StrokeDraw);
         if (flat_pen)
@@ -3627,7 +3627,7 @@ void QPainter::drawPoints(const QPoint *points, int pointCount)
         QPainterPath path;
         for (int i=0; i<pointCount; ++i) {
             path.moveTo(points[i].x(), points[i].y());
-            path.lineTo(points[i].x() + 0.0001, points[i].y());
+            path.lineTo(points[i].x() + qreal(0.0001), points[i].y());
         }
         d->draw_helper(path, QPainterPrivate::StrokeDraw);
         if (flat_pen)
@@ -4291,8 +4291,9 @@ void QPainter::drawArc(const QRectF &r, int a, int alen)
     QRectF rect = r.normalized();
 
     QPainterPath path;
-    path.arcMoveTo(rect, a/16.0);
-    path.arcTo(rect, a/16.0, alen/16.0);
+    const qreal inv_16 = 1 / qreal(16.0);
+    path.arcMoveTo(rect, a * inv_16);
+    path.arcTo(rect, a * inv_16, alen * inv_16);
     strokePath(path, d->state->pen);
 }
 
@@ -4361,8 +4362,9 @@ void QPainter::drawPie(const QRectF &r, int a, int alen)
     QRectF rect = r.normalized();
 
     QPainterPath path;
+    const qreal inv_16 = 1 / qreal(16.0);
     path.moveTo(rect.center());
-    path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a/16.0, alen/16.0);
+    path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a * inv_16, alen * inv_16);
     path.closeSubpath();
     drawPath(path);
 
@@ -4423,8 +4425,9 @@ void QPainter::drawChord(const QRectF &r, int a, int alen)
     QRectF rect = r.normalized();
 
     QPainterPath path;
-    path.arcMoveTo(rect, a/16.0);
-    path.arcTo(rect, a/16.0, alen/16.0);
+    const qreal inv_16 = 1 / qreal(16.0);
+    path.arcMoveTo(rect, a * inv_16);
+    path.arcTo(rect, a * inv_16, alen * inv_16);
     path.closeSubpath();
     drawPath(path);
 }
@@ -5926,7 +5929,7 @@ static QPainterPath generateWavyPath(qreal minWidth, qreal maxRadius, QPaintDevi
     QPainterPath path;
 
     bool up = true;
-    const qreal radius = qMax(qreal(.5), qMin(qreal(1.25 * device->logicalDpiY() / qt_defaultDpi()), maxRadius));
+    const qreal radius = qMax(qreal(.5), qMin(qreal(1.25) * device->logicalDpiY() / qt_defaultDpi(), maxRadius));
     qreal xs, ys;
     int i = 0;
     path.moveTo(0, radius);
@@ -6006,7 +6009,7 @@ static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const
 
     if (ti.flags & QTextItem::StrikeOut) {
         QLineF strikeOutLine = line;
-        strikeOutLine.translate(0., - fe->ascent().toReal() / 3.);
+        strikeOutLine.translate(qreal(0.), - fe->ascent().toReal() / qreal(3.));
         painter->setPen(pen);
         painter->drawLine(strikeOutLine);
     }
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 8133793..0f31cca 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -799,8 +799,9 @@ void QPainterPath::quadTo(const QPointF &c, const QPointF &e)
     if (prev == c && c == e)
         return;
 
-    QPointF c1((prev.x() + 2*c.x()) / 3, (prev.y() + 2*c.y()) / 3);
-    QPointF c2((e.x() + 2*c.x()) / 3, (e.y() + 2*c.y()) / 3);
+    const qreal inv_3 = 1 / qreal(3);
+    QPointF c1((prev.x() + 2*c.x()) * inv_3, (prev.y() + 2*c.y()) * inv_3);
+    QPointF c2((e.x() + 2*c.x()) * inv_3, (e.y() + 2*c.y()) * inv_3);
     cubicTo(c1, c2, e);
 }
 
@@ -1804,22 +1805,24 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y
         return false;
 
     if (p1 | p2) {
-        qreal dx = x2 - x1;
-        qreal dy = y2 - y1;
+        const qreal dx = x2 - x1;
+        const qreal dy = y2 - y1;
+        const qreal dx_dy_ratio = dx / dy;
+        const qreal dy_dx_ratio = dy / dx;
 
         // clip x coordinates
         if (x1 < left) {
-            y1 += dy/dx * (left - x1);
+            y1 += dy_dx_ratio * (left - x1);
             x1 = left;
         } else if (x1 > right) {
-            y1 -= dy/dx * (x1 - right);
+            y1 -= dy_dx_ratio * (x1 - right);
             x1 = right;
         }
         if (x2 < left) {
-            y2 += dy/dx * (left - x2);
+            y2 += dy_dx_ratio * (left - x2);
             x2 = left;
         } else if (x2 > right) {
-            y2 -= dy/dx * (x2 - right);
+            y2 -= dy_dx_ratio * (x2 - right);
             x2 = right;
         }
 
@@ -1833,17 +1836,17 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y
 
         // clip y coordinates
         if (y1 < top) {
-            x1 += dx/dy * (top - y1);
+            x1 += dx_dy_ratio * (top - y1);
             y1 = top;
         } else if (y1 > bottom) {
-            x1 -= dx/dy * (y1 - bottom);
+            x1 -= dx_dy_ratio * (y1 - bottom);
             y1 = bottom;
         }
         if (y2 < top) {
-            x2 += dx/dy * (top - y2);
+            x2 += dx_dy_ratio * (top - y2);
             y2 = top;
         } else if (y2 > bottom) {
-            x2 -= dx/dy * (y2 - bottom);
+            x2 -= dx_dy_ratio * (y2 - bottom);
             y2 = bottom;
         }
 
diff --git a/src/gui/painting/qpainterpath_p.h b/src/gui/painting/qpainterpath_p.h
index 54b9392..a2bc905 100644
--- a/src/gui/painting/qpainterpath_p.h
+++ b/src/gui/painting/qpainterpath_p.h
@@ -258,7 +258,7 @@ inline void QPainterPathData::maybeMoveTo()
     }
 }
 
-#define KAPPA 0.5522847498
+#define KAPPA qreal(0.5522847498)
 
 
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp
index ab2dc33..1568ad8 100644
--- a/src/gui/painting/qpathclipper.cpp
+++ b/src/gui/painting/qpathclipper.cpp
@@ -321,11 +321,11 @@ void QIntersectionFinder::intersectLines(const QLineF &a, const QLineF &b, QData
     if (p1_equals_q1 || p1_equals_q2 || p2_equals_q1 || p2_equals_q2)
         return;
 
-
+    const qreal inv_par = 1 / qreal(par);
     const qreal tp = (qDelta.y() * (q1.x() - p1.x()) -
-                      qDelta.x() * (q1.y() - p1.y())) / par;
+                      qDelta.x() * (q1.y() - p1.y())) * inv_par;
     const qreal tq = (pDelta.y() * (q1.x() - p1.x()) -
-                      pDelta.x() * (q1.y() - p1.y())) / par;
+                      pDelta.x() * (q1.y() - p1.y())) * inv_par;
 
     if (tp<0 || tp>1 || tq<0 || tq>1)
         return;
@@ -1192,24 +1192,24 @@ static qreal computeAngle(const QPointF &v)
 {
 #if 1
     if (v.x() == 0) {
-        return v.y() <= 0 ? 0 : 64.;
+        return v.y() <= 0 ? 0 : qreal(64.);
     } else if (v.y() == 0) {
-        return v.x() <= 0 ? 32. : 96.;
+        return v.x() <= 0 ? qreal(32.) : qreal(96.);
     }
 
     QPointF nv = normalize(v);
     if (nv.y() < 0) {
         if (nv.x() < 0) { // 0 - 32
-            return -32. * nv.x();
+            return qreal(-32.) * nv.x();
         } else { // 96 - 128
-            return 128. - 32. * nv.x();
+            return qreal(128.) - qreal(32.) * nv.x();
         }
     } else { // 32 - 96
-        return 64. + 32 * nv.x();
+        return qreal(64.) + 32 * nv.x();
     }
 #else
     // doesn't seem to be robust enough
-    return atan2(v.x(), v.y()) + Q_PI;
+    return qAtan2(v.x(), v.y()) + Q_PI;
 #endif
 }
 
diff --git a/src/gui/painting/qrasterizer.cpp b/src/gui/painting/qrasterizer.cpp
index b602690..ba5eda6 100644
--- a/src/gui/painting/qrasterizer.cpp
+++ b/src/gui/painting/qrasterizer.cpp
@@ -44,6 +44,7 @@
 #include <QPoint>
 #include <QRect>
 
+#include <qmath.h>
 #include <private/qmath_p.h>
 #include <private/qdatabuffer_p.h>
 #include <private/qdrawhelper_p.h>
@@ -51,8 +52,8 @@
 QT_BEGIN_NAMESPACE
 
 typedef int Q16Dot16;
-#define Q16Dot16ToFloat(i) ((i)/65536.)
-#define FloatToQ16Dot16(i) (int)((i) * 65536.)
+#define Q16Dot16ToFloat(i) ((i)/qreal(65536.))
+#define FloatToQ16Dot16(i) (int)((i) * qreal(65536.))
 #define IntToQ16Dot16(i) ((i) << 16)
 #define Q16Dot16ToInt(i) ((i) >> 16)
 #define Q16Dot16Factor 65536
@@ -707,12 +708,12 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
     if (a == b || width == 0 || d->clipRect.isEmpty())
         return;
 
-    Q_ASSERT(width > 0.0);
+    Q_ASSERT(width > qreal(0.0));
 
     QPointF pa = a;
     QPointF pb = b;
 
-    QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * 0.5;    
+    QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * qreal(0.5);
     if (squareCap)
         offs += QPointF(offs.y(), offs.x());
     const QRectF clip(d->clipRect.topLeft() - offs, d->clipRect.bottomRight() + QPoint(1, 1) + offs);
@@ -750,10 +751,12 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
     }
 
     if (!d->antialiased) {
-        pa.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.;
-        pa.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.;
-        pb.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.;
-        pb.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.;
+        const qreal inv_64 =  1 / qreal(64.);
+        const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64;
+        pa.rx() += delta;
+        pa.ry() += delta;
+        pb.rx() += delta;
+        pb.ry() += delta;
     }
 
     {
@@ -778,7 +781,7 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
             return;
 
         // adjust width which is given relative to |b - a|
-        width *= sqrt(w0 / w);
+        width *= qSqrt(w0 / w);
     }
 
     QSpanBuffer buffer(d->blend, d->data, d->clipRect);
@@ -793,10 +796,11 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
         pa = QPointF(x, y - dy);
         pb = QPointF(x, y + dy);
 
+        const qreal inv_width = 1 / width;
         if (squareCap)
-            width = 1 / width + 1.0f;
+            width = inv_width + 1.0f;
         else
-            width = 1 / width;
+            width = inv_width;
 
         squareCap = false;
     }
@@ -1192,8 +1196,10 @@ void QRasterizer::rasterize(const QPainterPath &path, Qt::FillRule fillRule)
 
     QRectF bounds = path.controlPointRect();
 
-    int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.));
-    int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.));
+    const qreal inv_64 = 1 / qreal(64.);
+    const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64 ;
+    int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + qreal(0.5) + delta));
+    int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - qreal(0.5) + delta));
 
     if (iTopBound > iBottomBound)
         return;
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index 228a6b1..b33d86b 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -788,12 +788,12 @@ qreal qt_t_for_arc_angle(qreal angle)
     if (qFuzzyCompare(angle, qreal(90)))
         return 1;
 
-    qreal radians = Q_PI * angle / 180;
+    qreal radians = Q_PI180 * angle;
     qreal cosAngle = qCos(radians);
     qreal sinAngle = qSin(radians);
 
     // initial guess
-    qreal tc = angle / 90;
+    qreal tc = angle / qreal(90);
     // do some iterations of newton's method to approximate cosAngle
     // finds the zero of the function b.pointAt(tc).x() - cosAngle
     tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value
@@ -812,7 +812,7 @@ qreal qt_t_for_arc_angle(qreal angle)
 
     // use the average of the t that best approximates cosAngle
     // and the t that best approximates sinAngle
-    qreal t = 0.5 * (tc + ts);
+    qreal t = qreal(0.5) * (tc + ts);
 
 #if 0
     printf("angle: %f, t: %f\n", angle, t);
@@ -861,11 +861,11 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt
     qreal y = rect.y();
 
     qreal w = rect.width();
-    qreal w2 = rect.width() / 2;
+    qreal w2 = rect.width() * qreal(0.5);
     qreal w2k = w2 * QT_PATH_KAPPA;
 
     qreal h = rect.height();
-    qreal h2 = rect.height() / 2;
+    qreal h2 = rect.height() * qreal(0.5);
     qreal h2k = h2 * QT_PATH_KAPPA;
 
     QPointF points[16] =
@@ -898,23 +898,24 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt
     else if (sweepLength < -360) sweepLength = -360;
 
     // Special case fast paths
-    if (startAngle == 0.0) {
-        if (sweepLength == 360.0) {
+    if (startAngle == qreal(0.0)) {
+        if (sweepLength == qreal(360.0)) {
             for (int i = 11; i >= 0; --i)
                 curves[(*point_count)++] = points[i];
             return points[12];
-        } else if (sweepLength == -360.0) {
+        } else if (sweepLength == qreal(-360.0)) {
             for (int i = 1; i <= 12; ++i)
                 curves[(*point_count)++] = points[i];
             return points[0];
         }
     }
 
-    int startSegment = int(floor(startAngle / 90));
-    int endSegment = int(floor((startAngle + sweepLength) / 90));
+    qreal inv_90 = qreal(1) / qreal(90);
+    int startSegment = int(floor(startAngle * inv_90));
+    int endSegment = int(floor((startAngle + sweepLength) * inv_90));
 
-    qreal startT = (startAngle - startSegment * 90) / 90;
-    qreal endT = (startAngle + sweepLength - endSegment * 90) / 90;
+    qreal startT = (startAngle - startSegment * 90) * inv_90;
+    qreal endT = (startAngle + sweepLength - endSegment * 90) * inv_90;
 
     int delta = sweepLength > 0 ? 1 : -1;
     if (delta < 0) {
diff --git a/src/gui/painting/qstroker_p.h b/src/gui/painting/qstroker_p.h
index a10ebd9..5ff9d87 100644
--- a/src/gui/painting/qstroker_p.h
+++ b/src/gui/painting/qstroker_p.h
@@ -110,7 +110,7 @@ struct qfixed2d
 };
 #endif
 
-#define QT_PATH_KAPPA 0.5522847498
+#define QT_PATH_KAPPA qreal(0.5522847498)
 
 QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength,
                           QPointF *controlPoints, int *point_count);
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index 8118450..4732278 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -52,7 +52,7 @@
 
 QT_BEGIN_NAMESPACE
 
-#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001)
+#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? qreal(0.000001) : qreal(0.0001))
 
 #ifdef MAP
 #  undef MAP
@@ -82,7 +82,7 @@ QT_BEGIN_NAMESPACE
             if (t == TxProject) {                                       \
                 qreal w = (m_13 * FX_ + m_23 * FY_ + m_33);              \
                 if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP);     \
-                w = 1./w;                                               \
+                w = qreal(1.)/w;                                               \
                 nx *= w;                                                \
                 ny *= w;                                                \
             }                                                           \
@@ -369,8 +369,8 @@ QTransform QTransform::inverted(bool *invertible) const
         inv = !qFuzzyIsNull(affine._m11);
         inv &= !qFuzzyIsNull(affine._m22);
         if (inv) {
-            invert.affine._m11 = 1. / affine._m11;
-            invert.affine._m22 = 1. / affine._m22;
+            invert.affine._m11 = qreal(1.) / affine._m11;
+            invert.affine._m22 = qreal(1.) / affine._m22;
             invert.affine._dx = -affine._dx * invert.affine._m11;
             invert.affine._dy = -affine._dy * invert.affine._m22;
         }
@@ -1087,7 +1087,7 @@ QPoint QTransform::map(const QPoint &p) const
         x = affine._m11 * fx + affine._m21 * fy + affine._dx;
         y = affine._m12 * fx + affine._m22 * fy + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx + m_23 * fy + m_33);
+            qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33);
             x *= w;
             y *= w;
         }
@@ -1138,7 +1138,7 @@ QPointF QTransform::map(const QPointF &p) const
         x = affine._m11 * fx + affine._m21 * fy + affine._dx;
         y = affine._m12 * fx + affine._m22 * fy + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx + m_23 * fy + m_33);
+            qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33);
             x *= w;
             y *= w;
         }
@@ -1217,10 +1217,10 @@ QLine QTransform::map(const QLine &l) const
         x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx;
         y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33);
+            qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33);
             x1 *= w;
             y1 *= w;
-            w = 1./(m_13 * fx2 + m_23 * fy2 + m_33);
+            w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33);
             x2 *= w;
             y2 *= w;
         }
@@ -1276,10 +1276,10 @@ QLineF QTransform::map(const QLineF &l) const
         x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx;
         y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33);
+            qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33);
             x1 *= w;
             y1 *= w;
-            w = 1./(m_13 * fx2 + m_23 * fy2 + m_33);
+            w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33);
             x2 *= w;
             y2 *= w;
         }
@@ -1438,7 +1438,7 @@ struct QHomogeneousCoordinate
     QHomogeneousCoordinate(qreal x_, qreal y_, qreal w_) : x(x_), y(y_), w(w_) {}
 
     const QPointF toPoint() const {
-        qreal iw = 1. / w;
+        qreal iw = qreal(1.) / w;
         return QPointF(x * iw, y * iw);
     }
 };
@@ -1695,8 +1695,9 @@ bool QTransform::squareToQuad(const QPolygonF &quad, QTransform &trans)
         if (!bottom)
             return false;
 
-        g = gtop/bottom;
-        h = htop/bottom;
+        double inv_bottom = 1 / bottom;
+        g = gtop * inv_bottom;
+        h = htop * inv_bottom;
 
         a = dx1 - dx0 + g * dx1;
         b = dx3 - dx0 + h * dx3;
diff --git a/src/gui/styles/qcommonstyle.cpp b/src/gui/styles/qcommonstyle.cpp
index 4c9541b..4d3272c 100644
--- a/src/gui/styles/qcommonstyle.cpp
+++ b/src/gui/styles/qcommonstyle.cpp
@@ -3070,9 +3070,9 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a)
     int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition);
 
     if (dial->maximum == dial->minimum)
-        a = Q_PI / 2;
+        a = Q_PI2;
     else if (dial->dialWrapping)
-        a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI
+        a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI
             / (dial->maximum - dial->minimum);
     else
         a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI
@@ -3087,12 +3087,13 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a)
     int back = len / 2;
 
     QPolygonF arrow(3);
-    arrow[0] = QPointF(0.5 + xc + len * qCos(a),
-                       0.5 + yc - len * qSin(a));
-    arrow[1] = QPointF(0.5 + xc + back * qCos(a + Q_PI * 5 / 6),
-                       0.5 + yc - back * qSin(a + Q_PI * 5 / 6));
-    arrow[2] = QPointF(0.5 + xc + back * qCos(a - Q_PI * 5 / 6),
-                       0.5 + yc - back * qSin(a - Q_PI * 5 / 6));
+    const qreal five_div_by_six = 5 / 6;
+    arrow[0] = QPointF(qreal(0.5) + xc + len * qCos(a),
+                       qreal(0.5) + yc - len * qSin(a));
+    arrow[1] = QPointF(qreal(0.5) + xc + back * qCos(a + Q_PI * five_div_by_six),
+                       qreal(0.5) + yc - back * qSin(a + Q_PI * five_div_by_six));
+    arrow[2] = QPointF(qreal(0.5) + xc + back * qCos(a - Q_PI * five_div_by_six),
+                       qreal(0.5) + yc - back * qSin(a - Q_PI * five_div_by_six));
     return arrow;
 }
 
diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp
index e0fcb92..016b6a7 100644
--- a/src/gui/styles/qs60style.cpp
+++ b/src/gui/styles/qs60style.cpp
@@ -579,7 +579,7 @@ void QS60StylePrivate::drawRow(QS60StyleEnums::SkinParts start,
 
 #if 0
     painter->save();
-    painter->setOpacity(.3);
+    painter->setOpacity(qreal(.3));
     painter->fillRect(startRect, Qt::red);
     painter->fillRect(middleRect, Qt::green);
     painter->fillRect(endRect, Qt::blue);
@@ -1624,7 +1624,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
                     QS60StylePrivate::SF_PointNorth : QS60StylePrivate::SF_PointWest;
                 QS60StylePrivate::drawSkinPart(QS60StyleEnums::SP_QgnGrafBarWait, painter, progressRect, flags | orientationFlag);
             } else {
-                const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? 1.0
+                const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? qreal(1.0)
                     : (qreal)optionProgressBar->progress / optionProgressBar->maximum;
                 if (optionProgressBar->orientation == Qt::Horizontal) {
                     progressRect.setWidth(int(progressRect.width() * progressFactor));
@@ -1912,12 +1912,12 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
                 if (focusFrame->widget() && focusFrame->widget()->hasEditFocus())
                     editFocus = true;
             }
-            const qreal opacity = editFocus ? 0.65 : 0.45; // Trial and error factors. Feel free to improve.
+            const qreal opacity = editFocus ? qreal(0.65) : qreal(0.45); // Trial and error factors. Feel free to improve.
 #else
-            const qreal opacity = 0.5;
+            const qreal opacity = qreal(0.5);
 #endif
             // Because of Qts coordinate system, we need to tweak the rect by .5 pixels, otherwise it gets blurred.
-            const qreal rectAdjustment = (penWidth % 2) ? -.5 : 0;
+            const qreal rectAdjustment = (penWidth % 2) ? qreal(-.5) : 0;
 
             // Make sure that the pen stroke is inside the rect
             const QRectF adjustedRect =
@@ -1941,7 +1941,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
     case CE_Splitter:
         if (option->state & State_Sunken && option->state & State_Enabled) {
             painter->save();
-            painter->setOpacity(0.5);
+            painter->setOpacity(qreal(0.5));
             painter->setBrush(d->themePalette()->light());
             painter->setRenderHint(QPainter::Antialiasing);
             const qreal roundRectRadius = 4 * goldenRatio;
@@ -2019,8 +2019,8 @@ void QS60Style::drawPrimitive(PrimitiveElement element, const QStyleOption *opti
     case PE_IndicatorRadioButton: {
             QRect buttonRect = option->rect;
             //there is empty (a. 33%) space in svg graphics for radiobutton
-            const qreal reduceWidth = (qreal)buttonRect.width()/3.0;
-            const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : 1.0;
+            const qreal reduceWidth = (qreal)buttonRect.width()/qreal(3.0);
+            const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : qreal(1.0);
             // Try to occupy the full area
             const qreal scaler = 1 + (reduceWidth/rectWidth);
             buttonRect.setWidth((int)((buttonRect.width()-reduceWidth) * scaler));
diff --git a/src/gui/styles/qstyle.cpp b/src/gui/styles/qstyle.cpp
index ec238a9..6733209 100644
--- a/src/gui/styles/qstyle.cpp
+++ b/src/gui/styles/qstyle.cpp
@@ -2132,7 +2132,7 @@ int QStyle::sliderPositionFromValue(int min, int max, int logicalValue, int span
     uint p = upsideDown ? max - logicalValue : logicalValue - min;
 
     if (range > (uint)INT_MAX/4096) {
-        double dpos = (double(p))/(double(range)/span);
+        qreal dpos = (qreal(p))/(qreal(range)/span);
         return int(dpos);
     } else if (range > (uint)span) {
         return (2 * p * span + range) / (2*range);
diff --git a/src/gui/styles/qstylehelper.cpp b/src/gui/styles/qstylehelper.cpp
index af30f15..5b6f72f 100644
--- a/src/gui/styles/qstylehelper.cpp
+++ b/src/gui/styles/qstylehelper.cpp
@@ -117,15 +117,15 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset)
     const int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition);
     qreal a = 0;
     if (dial->maximum == dial->minimum)
-        a = Q_PI / 2;
+        a = Q_PI2;
     else if (dial->dialWrapping)
-        a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI
+        a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI
             / (dial->maximum - dial->minimum);
     else
         a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI
             / (dial->maximum - dial->minimum)) / 6;
-    qreal xc = width / 2.0;
-    qreal yc = height / 2.0;
+    const qreal xc = width * qreal(0.5);
+    const qreal yc = height * qreal(0.5);
     qreal len = r - QStyleHelper::calcBigLineSize(r) - 3;
     qreal back = offset * len;
     QPointF pos(QPointF(xc + back * qCos(a), yc - back * qSin(a)));
@@ -134,7 +134,7 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset)
 
 qreal angle(const QPointF &p1, const QPointF &p2)
 {
-    static const qreal rad_factor = 180 / Q_PI;
+    static const qreal rad_factor = Q_PI180;
     qreal _angle = 0;
 
     if (p1.x() == p2.x()) {
@@ -186,7 +186,7 @@ QPolygonF calcLines(const QStyleOptionSlider *dial)
     poly.resize(2 + 2 * notches);
     int smallLineSize = bigLineSize / 2;
     for (int i = 0; i <= notches; ++i) {
-        qreal angle = dial->dialWrapping ? Q_PI * 3 / 2 - i * 2 * Q_PI / notches
+        qreal angle = dial->dialWrapping ? Q_PI2 * 3 - i * Q_2PI / notches
                   : (Q_PI * 8 - i * 10 * Q_PI / notches) / 6;
         qreal s = qSin(angle);
         qreal c = qCos(angle);
@@ -215,7 +215,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
     const bool enabled = option->state & QStyle::State_Enabled;
     qreal r = qMin(width, height) / 2;
     r -= r/50;
-    const qreal penSize = r/20.0;
+    const qreal penSize = r/qreal(20.0);
 
     painter->save();
     painter->setRenderHint(QPainter::Antialiasing);
@@ -234,7 +234,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
     const qreal dx = option->rect.x() + d_ + (width - 2 * r) / 2 + 1;
     const qreal dy = option->rect.y() + d_ + (height - 2 * r) / 2 + 1;
 
-    QRectF br = QRectF(dx + 0.5, dy + 0.5,
+    QRectF br = QRectF(dx + qreal(0.5), dy + qreal(0.5),
                        int(r * 2 - 2 * d_ - 2),
                        int(r * 2 - 2 * d_ - 2));
     buttonColor.setHsv(buttonColor .hue(),
@@ -244,11 +244,11 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
 
     if (enabled) {
         // Drop shadow
-        qreal shadowSize = qMax(1.0, penSize/2.0);
+        const qreal shadowSize = qMax(qreal(1.0), penSize * qreal(0.5));
         QRectF shadowRect= br.adjusted(-2*shadowSize, -2*shadowSize,
                                        2*shadowSize, 2*shadowSize);
         QRadialGradient shadowGradient(shadowRect.center().x(),
-                                       shadowRect.center().y(), shadowRect.width()/2.0,
+                                       shadowRect.center().y(), shadowRect.width() * qreal(0.5),
                                        shadowRect.center().x(), shadowRect.center().y());
         shadowGradient.setColorAt(qreal(0.91), QColor(0, 0, 0, 40));
         shadowGradient.setColorAt(qreal(1.0), Qt::transparent);
@@ -260,7 +260,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
 
         // Main gradient
         QRadialGradient gradient(br.center().x() - br.width()/3, dy,
-                                 br.width()*1.3, br.center().x(),
+                                 br.width()*qreal(1.3), br.center().x(),
                                  br.center().y() - br.height()/2);
         gradient.setColorAt(0, buttonColor.lighter(110));
         gradient.setColorAt(qreal(0.5), buttonColor);
@@ -283,7 +283,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
                          qMin(160, highlight.saturation()),
                          qMax(230, highlight.value()));
         highlight.setAlpha(127);
-        p->setPen(QPen(highlight, 2.0));
+        p->setPen(QPen(highlight, qreal(2.0)));
         p->setBrush(Qt::NoBrush);
         p->drawEllipse(br.adjusted(-1, -1, 1, 1));
     }
@@ -302,7 +302,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
     dialGradient.setColorAt(1, buttonColor.darker(140));
     dialGradient.setColorAt(qreal(0.4), buttonColor.darker(120));
     dialGradient.setColorAt(0, buttonColor.darker(110));
-    if (penSize > 3.0) {
+    if (penSize > qreal(3.0)) {
         painter->setPen(QPen(QColor(0, 0, 0, 25), penSize));
         painter->drawLine(calcRadialPos(option, qreal(0.90)), calcRadialPos(option, qreal(0.96)));
     }
diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp
index ae1d33a..ae84442 100644
--- a/src/gui/styles/qstylesheetstyle.cpp
+++ b/src/gui/styles/qstylesheetstyle.cpp
@@ -1252,20 +1252,20 @@ QPainterPath QRenderRule::borderClip(QRect r)
     const QRectF rect(r);
     const int *borders = border()->borders;
     QPainterPath path;
-    qreal curY = rect.y() + borders[TopEdge]/2.0;
+    qreal curY = rect.y() + borders[TopEdge]*qreal(0.5);
     path.moveTo(rect.x() + tlr.width(), curY);
     path.lineTo(rect.right() - trr.width(), curY);
-    qreal curX = rect.right() - borders[RightEdge]/2.0;
+    qreal curX = rect.right() - borders[RightEdge]*qreal(0.5);
     path.arcTo(curX - 2*trr.width() + borders[RightEdge], curY,
                trr.width()*2 - borders[RightEdge], trr.height()*2 - borders[TopEdge], 90, -90);
 
     path.lineTo(curX, rect.bottom() - brr.height());
-    curY = rect.bottom() - borders[BottomEdge]/2.0;
+    curY = rect.bottom() - borders[BottomEdge]*qreal(0.5);
     path.arcTo(curX - 2*brr.width() + borders[RightEdge], curY - 2*brr.height() + borders[BottomEdge],
                brr.width()*2 - borders[RightEdge], brr.height()*2 - borders[BottomEdge], 0, -90);
 
     path.lineTo(rect.x() + blr.width(), curY);
-    curX = rect.left() + borders[LeftEdge]/2.0;
+    curX = rect.left() + borders[LeftEdge]*qreal(0.5);
     path.arcTo(curX, rect.bottom() - 2*blr.height() + borders[BottomEdge]/2,
                blr.width()*2 - borders[LeftEdge], blr.height()*2 - borders[BottomEdge], 270, -90);
 
diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp
index 447087c..4511709 100644
--- a/src/gui/text/qfont.cpp
+++ b/src/gui/text/qfont.cpp
@@ -309,7 +309,7 @@ QFontPrivate *QFontPrivate::smallCapsFontPrivate() const
     QFont font(const_cast<QFontPrivate *>(this));
     qreal pointSize = font.pointSizeF();
     if (pointSize > 0)
-        font.setPointSizeF(pointSize * .7);
+        font.setPointSizeF(pointSize * qreal(.7));
     else
         font.setPixelSize((font.pixelSize() * 7 + 5) / 10);
     scFont = font.d.data();
@@ -2143,7 +2143,7 @@ QDataStream &operator<<(QDataStream &s, const QFont &font)
 
     if (s.version() >= QDataStream::Qt_4_0) {
         // 4.0
-        double pointSize = font.d->request.pointSize;
+        qreal pointSize = font.d->request.pointSize;
         qint32 pixelSize = font.d->request.pixelSize;
         s << pointSize;
         s << pixelSize;
@@ -2205,7 +2205,7 @@ QDataStream &operator>>(QDataStream &s, QFont &font)
 
     if (s.version() >= QDataStream::Qt_4_0) {
         // 4.0
-        double pointSize;
+        qreal pointSize;
         qint32 pixelSize;
         s >> pointSize;
         s >> pixelSize;
diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp
index fb8444e..1ceb28b 100644
--- a/src/gui/text/qfontdatabase.cpp
+++ b/src/gui/text/qfontdatabase.cpp
@@ -1877,11 +1877,12 @@ QList<int> QFontDatabase::pointSizes(const QString &family,
                 smoothScalable = true;
                 goto end;
             }
+            const qreal pointsize_factor = qreal(72.0) / dpi;
             for (int l = 0; l < style->count; l++) {
                 const QtFontSize *size = style->pixelSizes + l;
 
                 if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) {
-                    const uint pointSize = qRound(size->pixelSize * 72.0 / dpi);
+                    const uint pointSize = qRound(size->pixelSize * pointsize_factor);
                     if (! sizes.contains(pointSize))
                         sizes.append(pointSize);
                 }
@@ -1984,11 +1985,12 @@ QList<int> QFontDatabase::smoothSizes(const QString &family,
                 smoothScalable = true;
                 goto end;
             }
+            const qreal pointsize_factor = qreal(72.0) / dpi;
             for (int l = 0; l < style->count; l++) {
                 const QtFontSize *size = style->pixelSizes + l;
 
                 if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) {
-                    const uint pointSize = qRound(size->pixelSize * 72.0 / dpi);
+                    const uint pointSize = qRound(size->pixelSize * pointsize_factor);
                     if (! sizes.contains(pointSize))
                         sizes.append(pointSize);
                 }
diff --git a/src/svg/qsvggenerator.cpp b/src/svg/qsvggenerator.cpp
index 2f80a92..248bf55 100644
--- a/src/svg/qsvggenerator.cpp
+++ b/src/svg/qsvggenerator.cpp
@@ -796,9 +796,9 @@ int QSvgGenerator::metric(QPaintDevice::PaintDeviceMetric metric) const
     case QPaintDevice::PdmDpiY:
         return d->engine->resolution();
     case QPaintDevice::PdmHeightMM:
-        return qRound(d->engine->size().height() * 25.4 / d->engine->resolution());
+        return qRound(d->engine->size().height() * (d->engine->resolution() / qreal(25.4)));
     case QPaintDevice::PdmWidthMM:
-        return qRound(d->engine->size().width() * 25.4 / d->engine->resolution());
+        return qRound(d->engine->size().width() * (d->engine->resolution() / qreal(25.4)));
     case QPaintDevice::PdmNumColors:
         return 0xffffffff;
     case QPaintDevice::PdmPhysicalDpiX:
@@ -842,8 +842,9 @@ bool QSvgPaintEngine::begin(QPaintDevice *)
     *d->stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>" << endl << "<svg";
 
     if (d->size.isValid()) {
-        qreal wmm = d->size.width() * 25.4 / d->resolution;
-        qreal hmm = d->size.height() * 25.4 / d->resolution;
+        const qreal mm_factor = d->resolution / qreal(25.4);
+        const qreal wmm = d->size.width() * mm_factor;
+        const qreal hmm = d->size.height() * mm_factor;
         *d->stream << " width=\"" << wmm << "mm\" height=\"" << hmm << "mm\"" << endl;
     }
 
diff --git a/src/svg/qsvggraphics.cpp b/src/svg/qsvggraphics.cpp
index 6552b69..cc3c170 100644
--- a/src/svg/qsvggraphics.cpp
+++ b/src/svg/qsvggraphics.cpp
@@ -332,11 +332,12 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states)
 
     // Force the font to have a size of 100 pixels to avoid truncation problems
     // when the font is very small.
-    qreal scale = 100.0 / p->font().pointSizeF();
+    const qreal scale = qreal(100.0) / p->font().pointSizeF();
+    const qreal inv_scale = p->font().pointSizeF() / qreal(100.0); // like '1/scale' but with less rounding errors
     Qt::Alignment alignment = states.textAnchor;
 
     QTransform oldTransform = p->worldTransform();
-    p->scale(1 / scale, 1 / scale);
+    p->scale(inv_scale, inv_scale);
 
     qreal y = 0;
     bool initial = true;
@@ -346,7 +347,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states)
 
     if (m_type == TEXTAREA) {
         if (alignment == Qt::AlignHCenter)
-            px += scaledSize.width() / 2;
+            px += scaledSize.width() * qreal(0.5);
         else if (alignment == Qt::AlignRight)
             px += scaledSize.width();
     }
@@ -459,7 +460,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states)
 
                 qreal x = 0;
                 if (alignment == Qt::AlignHCenter)
-                    x -= 0.5 * line.naturalTextWidth();
+                    x -= qreal(0.5) * line.naturalTextWidth();
                 else if (alignment == Qt::AlignRight)
                     x -= line.naturalTextWidth();
 
@@ -479,7 +480,7 @@ void QSvgText::draw(QPainter *p, QSvgExtraStates &states)
                     break;
                 }
 
-                y += 1.1 * line.height();
+                y += qreal(1.1) * line.height();
             }
             tl.draw(p, QPointF(px, py), QVector<QTextLayout::FormatRange>(), bounds);
 
diff --git a/src/svg/qsvghandler.cpp b/src/svg/qsvghandler.cpp
index 3ed918e..a340c05 100644
--- a/src/svg/qsvghandler.cpp
+++ b/src/svg/qsvghandler.cpp
@@ -66,6 +66,7 @@
 #include "qnumeric.h"
 #include "qvarlengtharray.h"
 #include "private/qmath_p.h"
+#include "private/qnumeric_p.h"
 
 #include "float.h"
 
@@ -908,7 +909,7 @@ static inline qreal convertToNumber(const QString &str, QSvgHandler *handler, bo
     QSvgHandler::LengthType type;
     qreal num = parseLength(str, type, handler, ok);
     if (type == QSvgHandler::LT_PERCENT) {
-        num = num/100.0;
+        num = num * qreal(0.01);
     }
     return num;
 }
@@ -943,13 +944,13 @@ static qreal convertToPixels(qreal len, bool , QSvgHandler::LengthType type)
     case QSvgHandler::LT_PC:
         break;
     case QSvgHandler::LT_PT:
-        return len * 1.25;
+        return len * qreal(1.25);
         break;
     case QSvgHandler::LT_MM:
-        return len * 3.543307;
+        return len * qreal(3.543307);
         break;
     case QSvgHandler::LT_CM:
-        return len * 35.43307;
+        return len * qreal(35.43307);
         break;
     case QSvgHandler::LT_IN:
         return len * 90;
@@ -1372,16 +1373,16 @@ static void pathArcSegment(QPainterPath &path,
     qreal t;
     qreal thHalf;
 
-    sinTh = qSin(xAxisRotation * (Q_PI / 180.0));
-    cosTh = qCos(xAxisRotation * (Q_PI / 180.0));
+    sinTh = qSin(xAxisRotation * Q_PI180);
+    cosTh = qCos(xAxisRotation * Q_PI180);
 
     a00 =  cosTh * rx;
     a01 = -sinTh * ry;
     a10 =  sinTh * rx;
     a11 =  cosTh * ry;
 
-    thHalf = 0.5 * (th1 - th0);
-    t = (8.0 / 3.0) * qSin(thHalf * 0.5) * qSin(thHalf * 0.5) / qSin(thHalf);
+    thHalf = qreal(0.5) * (th1 - th0);
+    t = (qreal(8.0) / qreal(3.0)) * qSin(thHalf * qreal(0.5)) * qSin(thHalf * qreal(0.5)) / qSin(thHalf);
     x1 = xc + qCos(th0) - t * qSin(th0);
     y1 = yc + qSin(th0) + t * qCos(th0);
     x3 = xc + qCos(th1);
@@ -1441,11 +1442,11 @@ static void pathArc(QPainterPath &path,
     rx = qAbs(rx);
     ry = qAbs(ry);
 
-    sin_th = qSin(x_axis_rotation * (Q_PI / 180.0));
-    cos_th = qCos(x_axis_rotation * (Q_PI / 180.0));
+    sin_th = qSin(x_axis_rotation * Q_PI180);
+    cos_th = qCos(x_axis_rotation * Q_PI180);
 
-    dx = (curx - x) / 2.0;
-    dy = (cury - y) / 2.0;
+    dx = (curx - x) * qreal(0.5);
+    dy = (cury - y) * qreal(0.5);
     dx1 =  cos_th * dx + sin_th * dy;
     dy1 = -sin_th * dx + cos_th * dy;
     Pr1 = rx * rx;
@@ -1459,10 +1460,12 @@ static void pathArc(QPainterPath &path,
         ry = ry * qSqrt(check);
     }
 
-    a00 =  cos_th / rx;
-    a01 =  sin_th / rx;
-    a10 = -sin_th / ry;
-    a11 =  cos_th / ry;
+    const qreal inv_rx = 1 / rx;
+    const qreal inv_ry = 1 / ry;
+    a00 =  cos_th * inv_rx;
+    a01 =  sin_th * inv_rx;
+    a10 = -sin_th * inv_ry;
+    a11 =  cos_th * inv_ry;
     x0 = a00 * curx + a01 * cury;
     y0 = a10 * curx + a11 * cury;
     x1 = a00 * x + a01 * y;
@@ -1473,12 +1476,12 @@ static void pathArc(QPainterPath &path,
        The arc fits a unit-radius circle in this space.
     */
     d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
-    sfactor_sq = 1.0 / d - 0.25;
+    sfactor_sq = qreal(1.0) / d - qreal(0.25);
     if (sfactor_sq < 0) sfactor_sq = 0;
     sfactor = qSqrt(sfactor_sq);
     if (sweep_flag == large_arc_flag) sfactor = -sfactor;
-    xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0);
-    yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0);
+    xc = qreal(0.5) * (x0 + x1) - sfactor * (y1 - y0);
+    yc = qreal(0.5) * (y0 + y1) + sfactor * (x1 - x0);
     /* (xc, yc) is center of the circle. */
 
     th0 = atan2(y0 - yc, x0 - xc);
@@ -1486,16 +1489,18 @@ static void pathArc(QPainterPath &path,
 
     th_arc = th1 - th0;
     if (th_arc < 0 && sweep_flag)
-        th_arc += 2 * Q_PI;
+        th_arc += Q_2PI;
     else if (th_arc > 0 && !sweep_flag)
-        th_arc -= 2 * Q_PI;
+        th_arc -= Q_2PI;
 
-    n_segs = qCeil(qAbs(th_arc / (Q_PI * 0.5 + 0.001)));
+    n_segs = qCeil(qAbs(th_arc / (Q_PI2 + qreal(0.001))));
 
+    const qreal th_arc_div_n_segs = th_arc / n_segs;
     for (i = 0; i < n_segs; i++) {
+        const qreal i_mul_th_arc_div_n_segs = i * th_arc_div_n_segs;
         pathArcSegment(path, xc, yc,
-                       th0 + i * th_arc / n_segs,
-                       th0 + (i + 1) * th_arc / n_segs,
+                       th0 + i_mul_th_arc_div_n_segs,
+                       th0 + i_mul_th_arc_div_n_segs + th_arc_div_n_segs,
                        rx, ry, x_axis_rotation);
     }
 }
@@ -2969,10 +2974,10 @@ static QSvgNode *createRectNode(QSvgNode *parent,
     //9.2 The 'rect'  element clearly specifies it
     // but the case might in fact be handled because
     // we draw rounded rectangles differently
-    if (nrx > bounds.width()/2)
-        nrx = bounds.width()/2;
-    if (nry > bounds.height()/2)
-        nry = bounds.height()/2;
+    if (nrx > bounds.width()*qreal(0.5))
+        nrx = bounds.width()*qreal(0.5);
+    if (nry > bounds.height()*qreal(0.5))
+        nry = bounds.height()*qreal(0.5);
 
     if (nrx && !nry)
         nry = nrx;
@@ -2982,8 +2987,8 @@ static QSvgNode *createRectNode(QSvgNode *parent,
     //we draw rounded rect from 0...99
     //svg from 0...bounds.width()/2 so we're adjusting the
     //coordinates
-    nrx *= (100/(bounds.width()/2));
-    nry *= (100/(bounds.height()/2));
+    nrx *= (200/bounds.width());
+    nry *= (200/bounds.height());
 
     QSvgNode *rect = new QSvgRect(parent, bounds,
                                   int(nrx),
@@ -3073,7 +3078,7 @@ static bool parseStopNode(QSvgStyleProperty *parent,
     bool ok = true;
     qreal offset = convertToNumber(offsetStr, handler, &ok);
     if (!ok)
-        offset = 0.0;
+        offset = qreal(0.0);
     QString black = QString::fromLatin1("#000000");
     if (colorStr.isEmpty()) {
         colorStr = QStringRef(&black);
@@ -3093,9 +3098,9 @@ static bool parseStopNode(QSvgStyleProperty *parent,
     }
 
     // If offset is greater than one, it must be clamped to one.
-    if (offset > 1.0) {
-        if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < 1.0 - FLT_EPSILON)) {
-            stops.back().first = 1.0 - FLT_EPSILON;
+    if (offset > qreal(1.0)) {
+        if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < qreal(1.0) - FLT_EPSILON)) {
+            stops.back().first = qreal(1.0) - FLT_EPSILON;
             grad->setStops(stops);
         }
         offset = 1.0;
diff --git a/src/svg/qsvgtinydocument.cpp b/src/svg/qsvgtinydocument.cpp
index e2cefeb..21e9e9f 100644
--- a/src/svg/qsvgtinydocument.cpp
+++ b/src/svg/qsvgtinydocument.cpp
@@ -466,20 +466,19 @@ QMatrix QSvgTinyDocument::matrixForElement(const QString &id) const
 
 int QSvgTinyDocument::currentFrame() const
 {
-    double runningPercentage = qMin(m_time.elapsed()/double(m_animationDuration), 1.);
+    const qreal runningPercentage = qMin(qreal(m_time.elapsed()) / qreal(m_animationDuration), qreal(1.));
 
-    int totalFrames = m_fps * m_animationDuration;
+    const int totalFrames = m_fps * m_animationDuration;
 
     return int(runningPercentage * totalFrames);
 }
 
 void QSvgTinyDocument::setCurrentFrame(int frame)
 {
-    int totalFrames = m_fps * m_animationDuration;
-    double framePercentage = frame/double(totalFrames);
-    double timeForFrame = m_animationDuration * framePercentage; //in S
-    timeForFrame *= 1000; //in ms
-    int timeToAdd = int(timeForFrame - m_time.elapsed());
+    const int totalFrames = m_fps * m_animationDuration;
+    const qreal framePercentage = frame / totalFrames;
+    const qreal timeForFrame = m_animationDuration * framePercentage * 1000; //in ms
+    const int timeToAdd = int(timeForFrame - m_time.elapsed());
     m_time = m_time.addMSecs(timeToAdd);
 }