HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2775:143be951b1fe

Fix QNX build issue...

Titta Heikkala -

r2775:143be951b1fe

parent child

Context file:

r2775:143be951b1fe

Collapse all files

src/charts/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +1 -1

                     return points;
                 qreal adjustedMin = min() + 0.5;
-                qreal offset = (ceil(adjustedMin) - adjustedMin) * delta;
+                qreal offset = (qCeil(adjustedMin) - adjustedMin) * delta;
                 int count = qFloor(range);
                 if (count < 1)

src/charts/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +1 -1

                     return points;
                 qreal adjustedMin = min() + 0.5;
-                qreal offset = (ceil(adjustedMin) - adjustedMin) * delta;
+                qreal offset = (qCeil(adjustedMin) - adjustedMin) * delta;
                 int count = qFloor(range);
                 if (count < 1)

src/charts/axis/chartaxiselement.cpp +6 -5

             #include <QtCore/QtMath>
             #include <QtCore/QDateTime>
             #include <QtGui/QTextDocument>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
                     return labels;
                 if (format.isNull()) {
-                    int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0) + 1;
+                    int n = qMax(int(-qFloor(std::log10((max - min) / (ticks - 1)))), 0) + 1;
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << presenter()->numberToString(value, 'f', n);
                 int firstTick;
                 if (base > 1)
-                    firstTick = ceil(log10(min) / log10(base));
+                    firstTick = qCeil(std::log10(min) / std::log10(base));
                 else
-                    firstTick = ceil(log10(max) / log10(base));
+                    firstTick = qCeil(std::log10(max) / std::log10(base));
                 if (format.isNull()) {
                     int n = 0;
                     if (ticks > 1)
-                        n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
+                        n = qMax(int(-qFloor(std::log10((max - min) / (ticks - 1)))), 0);
                     n++;
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                 if (max <= min || ticks < 1)
                     return labels;
-                int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
+                int n = qMax(int(-qFloor(std::log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));

src/charts/axis/logvalueaxis/chartlogvalueaxisx.cpp +8 -7

             #include <QtWidgets/QGraphicsLayout>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             {
                 QVector<qreal> points;
-                qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
+                qreal logMax = std::log10(m_axis->max()) / std::log10(m_axis->base());
-                qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
+                qreal logMin = std::log10(m_axis->min()) / std::log10(m_axis->base());
                 qreal leftEdge = logMin < logMax ? logMin : logMax;
-                qreal ceilEdge = ceil(leftEdge);
+                qreal ceilEdge = qCeil(leftEdge);
-                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
+                int tickCount = qAbs(qCeil(logMax) - qCeil(logMin));
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList;
-                qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
+                qreal logMax = std::log10(m_axis->max()) / std::log10(m_axis->base());
-                qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
+                qreal logMin = std::log10(m_axis->min()) / std::log10(m_axis->base());
-                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
+                int tickCount = qAbs(qCeil(logMax) - qCeil(logMin));
                 if (m_axis->max() > m_axis->min() && tickCount > 0)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else

src/charts/axis/logvalueaxis/chartlogvalueaxisy.cpp +8 -7

             #include <QtWidgets/QGraphicsLayout>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             QVector<qreal> ChartLogValueAxisY::calculateLayout() const
             {
                 QVector<qreal> points;
-                qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
+                qreal logMax = std::log10(m_axis->max()) / std::log10(m_axis->base());
-                qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
+                qreal logMin = std::log10(m_axis->min()) / std::log10(m_axis->base());
                 qreal leftEdge = logMin < logMax ? logMin : logMax;
-                qreal ceilEdge = ceil(leftEdge);
+                qreal ceilEdge = qCeil(leftEdge);
-                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
+                int tickCount = qAbs(qCeil(logMax) - qCeil(logMin));
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList;
-                qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
+                qreal logMax = std::log10(m_axis->max()) / std::log10(m_axis->base());
-                qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
+                qreal logMin = std::log10(m_axis->min()) / std::log10(m_axis->base());
-                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
+                int tickCount = qAbs(qCeil(logMax) - qCeil(logMin));
                 if (m_axis->max() > m_axis->min() && tickCount > 0)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else

src/charts/axis/logvalueaxis/polarchartlogvalueaxisangular.cpp +5 -4

             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             QVector<qreal> PolarChartLogValueAxisAngular::calculateLayout() const
             {
                 QLogValueAxis *logValueAxis = static_cast<QLogValueAxis *>(axis());
-                const qreal logMax = log10(logValueAxis->max()) / log10(logValueAxis->base());
+                const qreal logMax = std::log10(logValueAxis->max()) / std::log10(logValueAxis->base());
-                const qreal logMin = log10(logValueAxis->min()) / log10(logValueAxis->base());
+                const qreal logMin = std::log10(logValueAxis->min()) / std::log10(logValueAxis->base());
                 const qreal startEdge = logMin < logMax ? logMin : logMax;
                 const qreal delta = 360.0 / qAbs(logMax - logMin);
-                const qreal initialSpan = (ceil(startEdge) - startEdge) * delta;
+                const qreal initialSpan = (qCeil(startEdge) - startEdge) * delta;
-                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
+                int tickCount = qAbs(qCeil(logMax) - qCeil(logMin));
                 QVector<qreal> points;
                 points.resize(tickCount);

src/charts/axis/logvalueaxis/polarchartlogvalueaxisradial.cpp +6 -5

             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             QVector<qreal> PolarChartLogValueAxisRadial::calculateLayout() const
             {
                 QLogValueAxis *logValueAxis = static_cast<QLogValueAxis *>(axis());
-                const qreal logMax = log10(logValueAxis->max()) / log10(logValueAxis->base());
+                const qreal logMax = std::log10(logValueAxis->max()) / std::log10(logValueAxis->base());
-                const qreal logMin = log10(logValueAxis->min()) / log10(logValueAxis->base());
+                const qreal logMin = std::log10(logValueAxis->min()) / std::log10(logValueAxis->base());
                 const qreal innerEdge = logMin < logMax ? logMin : logMax;
                 const qreal outerEdge = logMin > logMax ? logMin : logMax;
                 const qreal delta = (axisGeometry().width() / 2.0) / qAbs(logMax - logMin);
-                const qreal initialSpan = (ceil(innerEdge) - innerEdge) * delta;
+                const qreal initialSpan = (qCeil(innerEdge) - innerEdge) * delta;
-                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
+                int tickCount = qAbs(qCeil(logMax) - qCeil(logMin));
                 // Extra tick if outer edge is exactly at the tick
-                if (outerEdge == ceil(outerEdge))
+                if (outerEdge == qCeil(outerEdge))
                     tickCount++;
                 QVector<qreal> points;

src/charts/domain/abstractdomain.cpp +2 -1

             #include <private/abstractdomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCore/QtMath>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             qreal AbstractDomain::niceNumber(qreal x, bool ceiling)
             {
-                qreal z = qPow(10, qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
+                qreal z = qPow(10, qFloor(std::log10(x))); //find corresponding number of the form of 10^n than is smaller than x
                 qreal q = x / z; //q<10 && q>=1;
                 if (ceiling) {

src/charts/domain/logxlogydomain.cpp +15 -14

             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
-                    qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                    qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                    qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                    qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                     m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                     m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                     if(!m_signalsBlocked)
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
-                    qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                    qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                    qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                    qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                     m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                     if (!m_signalsBlocked)
                 qreal x(0);
                 qreal y(0);
                 if (point.x() > 0 && point.y() > 0) {
-                    x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
+                    x = (std::log10(point.x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
-                    y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
+                    y = (std::log10(point.y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                     ok = true;
                 } else {
                     qWarning() << "Logarithms of zero and negative values are undefined.";
                     ok = false;
                     if (point.x() > 0)
-                        x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
+                        x = (std::log10(point.x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                     else
                         x = 0;
                     if (point.y() > 0) {
-                        y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY
+                        y = (std::log10(point.y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY
                                 + m_size.height();
                     } else {
                         y = m_size.height();
                 for (int i = 0; i < vector.count(); ++i) {
                     if (vector[i].x() > 0 && vector[i].y() > 0) {
-                        qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
+                        qreal x = (std::log10(vector[i].x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
-                        qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
+                        qreal y = (std::log10(vector[i].y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
             void LogXLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
-                qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                 emit updated();
             void LogXLogYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
-                qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                 emit updated();

src/charts/domain/logxlogypolardomain.cpp +11 -10

             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
-                    qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                    qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                    qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                    qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                     m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                     m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                     if (!m_signalsBlocked)
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
-                    qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                    qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                    qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                    qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                     m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
                     if (!m_signalsBlocked)
                 } else {
                     ok =  true;
                     const qreal tickSpan = 360.0 / qAbs(m_logRightX - m_logLeftX);
-                    const qreal logValue = log10(value) / log10(m_logBaseX);
+                    const qreal logValue = std::log10(value) / std::log10(m_logBaseX);
                     const qreal valueDelta = logValue - m_logLeftX;
                     retVal = valueDelta * tickSpan;
                 } else {
                     ok =  true;
                     const qreal tickSpan = m_radius / qAbs(m_logOuterY - m_logInnerY);
-                    const qreal logValue = log10(value) / log10(m_logBaseY);
+                    const qreal logValue = std::log10(value) / std::log10(m_logBaseY);
                     const qreal valueDelta = logValue - m_logInnerY;
                     retVal = valueDelta * tickSpan;
             void LogXLogYPolarDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
-                qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                 emit updated();
             void LogXLogYPolarDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
-                qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                 m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
                 m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
                 emit updated();

src/charts/domain/logxydomain.cpp +7 -6

             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
-                    qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                    qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                    qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                    qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                     m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                     m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                     if(!m_signalsBlocked)
                 qreal x(0);
                 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
                 if (point.x() > 0) {
-                    x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
+                    x = (std::log10(point.x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                     ok = true;
                 } else {
                     x = 0;
                 for (int i = 0; i < vector.count(); ++i) {
                     if (vector[i].x() > 0) {
-                        qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
+                        qreal x = (std::log10(vector[i].x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                         qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
                         result[i].setX(x);
                         result[i].setY(y);
             void LogXYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
-                qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                 emit updated();

src/charts/domain/logxypolardomain.cpp +6 -5

             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
-                    qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                    qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                    qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                    qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                     m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                     m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                     if (!m_signalsBlocked)
                 } else {
                     ok =  true;
                     const qreal tickSpan = 360.0 / qAbs(m_logRightX - m_logLeftX);
-                    const qreal logValue = log10(value) / log10(m_logBaseX);
+                    const qreal logValue = std::log10(value) / std::log10(m_logBaseX);
                     const qreal valueDelta = logValue - m_logLeftX;
                     retVal = valueDelta * tickSpan;
             void LogXYPolarDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
-                qreal logMinX = log10(m_minX) / log10(m_logBaseX);
+                qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
-                qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
+                qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                 emit updated();

src/charts/domain/xlogydomain.cpp +7 -6

             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
-                    qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                    qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                    qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                    qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                     m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                     if (!m_signalsBlocked)
                 qreal x = (point.x() - m_minX) * deltaX;
                 qreal y(0);
                 if (point.y() > 0) {
-                    y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
+                    y = (std::log10(point.y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                     ok = true;
                 } else {
                     y = m_size.height();
                 for (int i = 0; i < vector.count(); ++i) {
                     if (vector[i].y() > 0) {
                         qreal x = (vector[i].x() - m_minX) * deltaX;
-                        qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
+                        qreal y = (std::log10(vector[i].y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
             void XLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
-                qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                 emit updated();

src/charts/domain/xlogypolardomain.cpp +6 -5

             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
+            #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
-                    qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                    qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                    qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                    qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                     m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
                     if (!m_signalsBlocked)
                 } else {
                     ok =  true;
                     const qreal tickSpan = m_radius / qAbs(m_logOuterY - m_logInnerY);
-                    const qreal logValue = log10(value) / log10(m_logBaseY);
+                    const qreal logValue = std::log10(value) / std::log10(m_logBaseY);
                     const qreal valueDelta = logValue - m_logInnerY;
                     retVal = valueDelta * tickSpan;
             void XLogYPolarDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
-                qreal logMinY = log10(m_minY) / log10(m_logBaseY);
+                qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
-                qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
+                qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                 m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
                 m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
                 emit updated();

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages