void tst_QNumeric::qNan()
{
#if defined __FAST_MATH__ && (__GNUC__ * 100 + __GNUC_MINOR__ < 404)
QSKIP("Non-conformant fast math mode is enabled, cannot run test");
#endif
double nan = qQNaN();
QVERIFY(!(0 > nan));
QVERIFY(!(0 < nan));
QVERIFY(qIsNaN(nan));
QVERIFY(qIsNaN(nan + 1));
QVERIFY(qIsNaN(-nan));
double inf = qInf();
QVERIFY(inf > 0);
QVERIFY(-inf < 0);
QVERIFY(qIsInf(inf));
QVERIFY(qIsInf(-inf));
QVERIFY(qIsInf(2*inf));
QCOMPARE(1/inf, 0.0);
#ifdef Q_CC_INTEL
QEXPECT_FAIL("", "ICC optimizes zero * anything to zero", Continue);
#endif
QVERIFY(qIsNaN(0*nan));
#ifdef Q_CC_INTEL
QEXPECT_FAIL("", "ICC optimizes zero * anything to zero", Continue);
#endif
QVERIFY(qIsNaN(0*inf));
QVERIFY(qFuzzyCompare(1/inf, 0.0));
}
void tst_QNumeric::qNan()
{
double nan = qQNaN();
#if defined( __INTEL_COMPILER)
QCOMPARE((0 > nan), false);
QCOMPARE((0 < nan), false);
QSKIP("This fails due to a bug in the Intel Compiler", SkipAll);
#else
if (0 > nan)
QFAIL("compiler thinks 0 > nan");
# if defined(Q_CC_DIAB)
QWARN("!(0 < nan) would fail due to a bug in dcc");
# else
if (0 < nan)
QFAIL("compiler thinks 0 < nan");
# endif
#endif
QVERIFY(qIsNaN(nan));
QVERIFY(qIsNaN(nan + 1));
QVERIFY(qIsNaN(-nan));
double inf = qInf();
QVERIFY(inf > 0);
QVERIFY(-inf < 0);
QVERIFY(qIsInf(inf));
QVERIFY(qIsInf(-inf));
QVERIFY(qIsInf(2*inf));
QCOMPARE(1/inf, 0.0);
QVERIFY(qIsNaN(0*nan));
QVERIFY(qIsNaN(0*inf));
QVERIFY(qFuzzyCompare(1/inf, 0.0));
}
void UBWidgetUniboardAPI::eraseLineTo(const qreal x, const qreal y, const qreal pWidth)
{
if (qIsNaN(x) || qIsNaN(y) || qIsNaN(pWidth)
|| qIsInf(x) || qIsInf(y) || qIsInf(pWidth))
return;
if (mScene)
mScene->eraseLineTo(QPointF(x, y), pWidth);
}
void UBWidgetUniboardAPI::moveTo(const qreal x, const qreal y)
{
if (qIsNaN(x) || qIsNaN(y)
|| qIsInf(x) || qIsInf(y))
return;
if (mScene)
mScene->moveTo(QPointF(x, y));
}
void UBWidgetUniboardAPI::drawLineTo(const qreal x, const qreal y, const qreal pWidth)
{
if (qIsNaN(x) || qIsNaN(y) || qIsNaN(pWidth)
|| qIsInf(x) || qIsInf(y) || qIsInf(pWidth))
return;
if (mScene)
mScene->drawLineTo(QPointF(x, y), pWidth,
UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Line);
}
void QScatterDataProxyPrivate::limitValues(QVector3D &minValues, QVector3D &maxValues,
QAbstract3DAxis *axisX, QAbstract3DAxis *axisY,
QAbstract3DAxis *axisZ) const
{
if (m_dataArray->isEmpty())
return;
const QVector3D &firstPos = m_dataArray->at(0).position();
float minX = firstPos.x();
float maxX = minX;
float minY = firstPos.y();
float maxY = minY;
float minZ = firstPos.z();
float maxZ = minZ;
if (m_dataArray->size() > 1) {
for (int i = 1; i < m_dataArray->size(); i++) {
const QVector3D &pos = m_dataArray->at(i).position();
float value = pos.x();
if (qIsNaN(value) || qIsInf(value))
continue;
if (isValidValue(minX, value, axisX))
minX = value;
if (maxX < value)
maxX = value;
value = pos.y();
if (qIsNaN(value) || qIsInf(value))
continue;
if (isValidValue(minY, value, axisY))
minY = value;
if (maxY < value)
maxY = value;
value = pos.z();
if (qIsNaN(value) || qIsInf(value))
continue;
if (isValidValue(minZ, value, axisZ))
minZ = value;
if (maxZ < value)
maxZ = value;
}
}
minValues.setX(minX);
minValues.setY(minY);
minValues.setZ(minZ);
maxValues.setX(maxX);
maxValues.setY(maxY);
maxValues.setZ(maxZ);
}
void UBWidgetUniboardAPI::centerOn(const qreal x, const qreal y)
{
if (qIsNaN(x) || qIsNaN(y)
|| qIsInf(x) || qIsInf(y))
return;
if (UBApplication::boardController->activeScene() != mScene)
return;
UBApplication::boardController->centerOn(QPointF(x, y));
}
void UBWidgetUniboardAPI::move(const qreal x, const qreal y)
{
if (qIsNaN(x) || qIsNaN(y)
|| qIsInf(x) || qIsInf(y))
return;
if (UBApplication::boardController->activeScene() != mScene)
return;
UBApplication::boardController->handScroll(x, y);
}
void UBWidgetUniboardAPI::resize(qreal width, qreal height)
{
if (qIsNaN(width) || qIsNaN(height)
|| qIsInf(width) || qIsInf(height))
return;
if (mGraphicsWidget)
{
mGraphicsWidget->resize(width, height);
}
}
void UBWidgetUniboardAPI::zoom(const qreal factor, const qreal x, const qreal y)
{
if (qIsNaN(factor) || qIsNaN(x) || qIsNaN(y)
|| qIsInf(factor) || qIsInf(x) || qIsInf(y))
return;
if (UBApplication::boardController->activeScene() != mScene)
return;
UBApplication::boardController->zoom(factor, QPointF(x, y));
}
bool QgsRectangle::isFinite() const
{
if ( qIsInf( xmin ) || qIsInf( ymin ) || qIsInf( xmax ) || qIsInf( ymax ) )
{
return false;
}
if ( qIsNaN( xmin ) || qIsNaN( ymin ) || qIsNaN( xmax ) || qIsNaN( ymax ) )
{
return false;
}
return true;
}
void UBWidgetUniboardAPI::addText(const QString& text, const qreal x, const qreal y, const int size, const QString& font
, bool bold, bool italic)
{
if (qIsNaN(x) || qIsNaN(y)
|| qIsInf(x) || qIsInf(y))
return;
if (UBApplication::boardController->activeScene() != mScene)
return;
if (mScene)
mScene->addTextWithFont(text, QPointF(x, y), size, font, bold, italic);
}
void GImagePixelAdder::ProcessImageAOIed(const GImageDouble & aoiImage)
{
IncrementCountProcessed();
int Npix = aoiImage.size().width() * aoiImage.size().height();
int hei = aoiImage.size().height();
int wid = aoiImage.size().width();
GDoubleArray & zArray = aoiImage.DoubleArray();
double sum = 0;
double sumSquare = 0;
int pxTot = 0;
for(int i = 0; i < Npix; i++) {
double valPix = zArray[i];
if(qIsNaN(valPix) || qIsInf(valPix))
continue;
pxTot++;
sum += valPix;
sumSquare += valPix * valPix;
}
if(!pxTot)
return;
double dNpixTot = double(pxTot);
m_SumPix = sum;
sum /= dNpixTot;
sumSquare /= dNpixTot;
m_AvePix = sum;
m_StdDevPix = qSqrt(sumSquare - sum * sum);
}
void tst_QScriptValueGenerated::qscriptvalue_castqsreal_test(const char*, const QScriptValue& value)
{
QFETCH(qsreal, expected);
if (qIsNaN(expected)) {
QVERIFY(qIsNaN(qscriptvalue_cast<qsreal>(value)));
QVERIFY(qIsNaN(qscriptvalue_cast<qsreal>(value)));
return;
}
if (qIsInf(expected)) {
QVERIFY(qIsInf(qscriptvalue_cast<qsreal>(value)));
QVERIFY(qIsInf(qscriptvalue_cast<qsreal>(value)));
return;
}
QCOMPARE(qscriptvalue_cast<qsreal>(value), expected);
QCOMPARE(qscriptvalue_cast<qsreal>(value), expected);
}
QString prepareToInsert<qsreal>(qsreal value)
{
if (qIsNaN(value))
return "qQNaN()";
if (qIsInf(value))
return "qInf()";
return QString::number(value, 'g', 16);
}
QScriptValueImpl Math::method_pow(QScriptContextPrivate *context,
QScriptEnginePrivate *eng,
QScriptClassInfo *)
{
qsreal x = context->argument(0).toNumber();
qsreal y = context->argument(1).toNumber();
if (qIsNaN(y))
return QScriptValueImpl(eng, qSNaN());
if (y == 0)
return QScriptValueImpl(eng, 1);
if (((x == 1) || (x == -1)) && qIsInf(y))
return QScriptValueImpl(eng, qSNaN());
if (((x == 0) && copySign(1.0, x) == 1.0) && (y < 0))
return QScriptValueImpl(eng, qInf());
if ((x == 0) && copySign(1.0, x) == -1.0) {
if (y < 0) {
if (::fmod(-y, 2.0) == 1.0)
return QScriptValueImpl(eng, -qInf());
else
return QScriptValueImpl(eng, qInf());
} else if (y > 0) {
if (::fmod(y, 2.0) == 1.0)
return QScriptValueImpl(eng, copySign(0, -1.0));
else
return QScriptValueImpl(eng, 0);
}
}
#ifdef Q_OS_AIX
if (qIsInf(x) && copySign(1.0, x) == -1.0) {
if (y > 0) {
if (::fmod(y, 2.0) == 1.0)
return QScriptValueImpl(eng, -qInf());
else
return QScriptValueImpl(eng, qInf());
} else if (y < 0) {
if (::fmod(-y, 2.0) == 1.0)
return QScriptValueImpl(eng, copySign(0, -1.0));
else
return QScriptValueImpl(eng, 0);
}
}
#endif
return (QScriptValueImpl(eng, ::pow(x, y)));
}
double KisDoubleParseSpinBox::valueFromText(const QString & text) const
{
lastExprParsed = text;
bool ok;
double ret;
if ( (suffix().isEmpty() || !text.endsWith(suffix())) &&
(prefix().isEmpty() || !text.startsWith(prefix())) ) {
ret = KisNumericParser::parseSimpleMathExpr(text, &ok);
} else {
QString expr = text;
if (text.endsWith(suffix())) {
expr.remove(text.size()-suffix().size(), suffix().size());
}
if(text.startsWith(prefix())){
expr.remove(0, prefix().size());
}
lastExprParsed = expr;
ret = KisNumericParser::parseSimpleMathExpr(expr, &ok);
}
if(qIsNaN(ret) || qIsInf(ret)){
ok = false;
}
if (!ok) {
if (boolLastValid) {
oldValue = value();
}
boolLastValid = false;
ret = oldValue; //in case of error set to minimum.
} else {
if (!boolLastValid) {
oldValue = ret;
}
boolLastValid = true;
}
return ret;
}
QScriptValueImpl Math::method_exp(QScriptContextPrivate *context,
QScriptEnginePrivate *eng,
QScriptClassInfo *)
{
qsreal v = context->argument(0).toNumber();
if (qIsInf(v)) {
if (copySign(1.0, v) == -1.0)
return QScriptValueImpl(eng, 0);
else
return QScriptValueImpl(eng, qInf());
}
return (QScriptValueImpl(eng, ::exp(v)));
}
bool RangeHistogram::ValidRange() const
{
if(qIsInf(m_WhitePoint) || qIsNaN(m_WhitePoint) || qIsInf(m_BlackPoint) || qIsNaN(m_BlackPoint) ||
qIsInf(m_RangeMax) || qIsNaN(m_RangeMax) || qIsInf(m_RangeMin) || qIsNaN(m_RangeMin) ||
qIsInf(m_RangeMax - m_RangeMin) || qIsNaN(m_RangeMax - m_RangeMin) ||
qIsInf(m_WhitePoint - m_BlackPoint) || qIsNaN(m_WhitePoint - m_BlackPoint))
{
return false;
}
return true;
}
bool QgsRaster::isRepresentableValue( double value, Qgis::DataType dataType )
{
switch ( dataType )
{
case Qgis::Byte:
return value >= std::numeric_limits<quint8>::min() && value <= std::numeric_limits<quint8>::max();
case Qgis::UInt16:
return value >= std::numeric_limits<quint16>::min() && value <= std::numeric_limits<quint16>::max();
case Qgis::Int16:
return value >= std::numeric_limits<qint16>::min() && value <= std::numeric_limits<qint16>::max();
case Qgis::UInt32:
return value >= std::numeric_limits<quint32>::min() && value <= std::numeric_limits<quint32>::max();
case Qgis::Int32:
return value >= std::numeric_limits<qint32>::min() && value <= std::numeric_limits<qint32>::max();
case Qgis::Float32:
return qIsNaN( value ) || qIsInf( value ) ||
( value >= -std::numeric_limits<float>::max() && value <= std::numeric_limits<float>::max() );
default:
return true;
break;
}
}
QScriptValueImpl Math::method_atan2(QScriptContextPrivate *context,
QScriptEnginePrivate *eng,
QScriptClassInfo *)
{
qsreal v1 = context->argument(0).toNumber();
qsreal v2 = context->argument(1).toNumber();
#ifdef Q_OS_WINCE
if (v1 == 0.0) {
const bool v1MinusZero = _copysign(1.0, v1) < 0.0;
const bool v2MinusZero = (v2 == 0 && _copysign(1.0, v2) < 0.0);
if ((v1MinusZero && v2MinusZero) || (v1MinusZero && v2 == -1.0))
return QScriptValueImpl(eng, -qt_PI);
if (v2MinusZero)
return QScriptValueImpl(eng, qt_PI);
if (v1MinusZero && v2 == 1.0)
return QScriptValueImpl(eng, -0.0);
#if defined(_X86_)
if (v2 == 0.0 && (v1MinusZero || (!v1MinusZero && !v2MinusZero)))
return QScriptValueImpl(eng, 0.0);
#endif
}
#endif
#if defined(Q_OS_WINCE) && defined(_X86_)
if (v1 == -1.0 && !_finite(v2) && _copysign(1.0, v2) > 0.0)
return QScriptValueImpl(eng, -0.0);
#endif
if ((v1 < 0) && qIsFinite(v1) && qIsInf(v2) && (copySign(1.0, v2) == 1.0))
return QScriptValueImpl(eng, copySign(0, -1.0));
if ((v1 == 0.0) && (v2 == 0.0)) {
if ((copySign(1.0, v1) == 1.0) && (copySign(1.0, v2) == -1.0))
return QScriptValueImpl(eng, qt_PI);
else if ((copySign(1.0, v1) == -1.0) && (copySign(1.0, v2) == -1.0))
return QScriptValueImpl(eng, -qt_PI);
}
return (QScriptValueImpl(eng, ::atan2(v1, v2)));
}
void PathObjectTest::virtualPathTest()
{
// Test open path
auto coords = MapCoordVector { { 0.0, 0.0 }, { 2.0, 0.0 }, { 2.0, 1.0 }, { 2.0, -1.0 } };
auto path = VirtualPath { coords };
auto tangent_scaling = path.calculateTangentScaling(0);
auto& scaling = tangent_scaling.second;
auto right = tangent_scaling.first.perpRight();
right.normalize();
QCOMPARE(right.length(), 1.0);
QCOMPARE(right.x(), 0.0);
QCOMPARE(right.y(), 1.0); // This looks like left, but our y axis is mirrored.
QCOMPARE(right.angle(), M_PI/2);
QCOMPARE(scaling, 1.0);
tangent_scaling = path.calculateTangentScaling(1);
right = tangent_scaling.first.perpRight();
right.normalize();
QCOMPARE(right.x(), -sqrt(2.0)/2);
QCOMPARE(right.y(), sqrt(2.0)/2);
QCOMPARE(right.angle(), 3*M_PI/4);
QCOMPARE(scaling, sqrt(2.0));
tangent_scaling = path.calculateTangentScaling(2);
right = tangent_scaling.first.perpRight();
right.normalize();
QCOMPARE(right.length(), 1.0);
QCOMPARE(right.x(), 0.0);
QCOMPARE(right.y(), 1.0);
QCOMPARE(right.angle(), M_PI/2);
QVERIFY(qIsInf(scaling));
tangent_scaling = path.calculateTangentScaling(3);
right = tangent_scaling.first.perpRight();
right.normalize();
QCOMPARE(right.length(), 1.0);
QCOMPARE(right.x(), 1.0);
QCOMPARE(right.y(), 0.0);
QCOMPARE(right.angle(), 0.0);
QCOMPARE(scaling, 1.0);
// Test close point
coords.emplace_back( 0.0, -1.0 );
coords.emplace_back( 0.0, 0.0 );
coords.back().setClosePoint(true);
path.last_index += 2;
tangent_scaling = path.calculateTangentScaling(0);
right = tangent_scaling.first.perpRight();
right.normalize();
QCOMPARE(right.length(), 1.0);
QCOMPARE(right.x(), -sqrt(2.0)/2);
QCOMPARE(right.y(), sqrt(2.0)/2);
QCOMPARE(right.angle(), 3*M_PI/4);
QCOMPARE(scaling, sqrt(2.0));
tangent_scaling = path.calculateTangentScaling(coords.size()-1);
right = tangent_scaling.first.perpRight();
right.normalize();
QCOMPARE(right.length(), 1.0);
QCOMPARE(right.x(), -sqrt(2.0)/2);
QCOMPARE(right.y(), sqrt(2.0)/2);
QCOMPARE(right.angle(), 3*M_PI/4);
QCOMPARE(scaling, sqrt(2.0));
}
bool QgsComposerNodesItem::addNode( const QPointF &pt,
const bool checkArea,
const double radius )
{
const QPointF start = mapFromScene( pt );
double minDistance = std::numeric_limits<double>::max();
double maxDistance = ( checkArea ) ? radius : minDistance;
bool rc = false;
int idx = -1;
for ( int i = 0; i != mPolygon.size(); i++ )
{
// get nodes of polyline
const QPointF pt1 = mPolygon.at( i );
QPointF pt2 = mPolygon.first();
if (( i + 1 ) != mPolygon.size() )
pt2 = mPolygon.at( i + 1 );
// compute line eq
const double coef = ( pt2.y() - pt1.y() ) / ( pt2.x() - pt1.x() );
const double b = pt1.y() - coef * pt1.x();
double distance = std::numeric_limits<double>::max();
if ( qIsInf( coef ) )
distance = qAbs( pt1.x() - start.x() );
else
{
const double coef2 = ( -1 / coef );
const double b2 = start.y() - coef2 * start.x();
QPointF inter;
if ( qIsInf( coef2 ) )
{
distance = qAbs( pt1.y() - start.y() );
inter.setX( start.x() );
inter.setY( pt1.y() );
}
else
{
const double interx = ( b - b2 ) / ( coef2 - coef );
const double intery = interx * coef2 + b2;
inter.setX( interx );
inter.setY( intery );
}
// check if intersection is within the line
const double length1 = computeDistance( inter, pt1 );
const double length2 = computeDistance( inter, pt2 );
const double length3 = computeDistance( pt1, pt2 );
const double length4 = length1 + length2;
if ( qAbs( length3 - length4 ) < std::numeric_limits<float>::epsilon() )
distance = computeDistance( inter, start );
}
if ( distance < minDistance && distance < maxDistance )
{
minDistance = distance;
idx = i;
}
}
if ( idx >= 0 )
{
rc = _addNode( idx, start, maxDistance );
updateSceneRect();
}
return rc;
}
