qwt_math.h

/******************************************************************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *
 * Modified by ChenZongYan in 2024 <czy.t@163.com>
 *   Summary of major modifications (see ChangeLog.md for full history):
 *   1. CMake build system & C++11 throughout.
 *   2. Core panner/ zoomer refactored:
 *        - QwtPanner → QwtCachePanner (pixmap-cache version)
 *        - New real-time QwtPlotPanner derived from QwtPicker.
 *   3. Zoomer supports multi-axis.
 *   4. Parasite-plot framework:
 *        - QwtFigure, QwtPlotParasiteLayout, QwtPlotTransparentCanvas,
 *        - QwtPlotScaleEventDispatcher, built-in pan/zoom on axis.
 *   5. New picker: QwtPlotSeriesDataPicker (works with date axis).
 *   6. Raster & color-map extensions:
 *        - QwtGridRasterData (2-D table + interpolation)
 *        - QwtLinearColorMap::stopColors(), stopPos() API rename.
 *   7. Bar-chart: expose pen/brush control.
 *   8. Amalgamated build: single QwtPlot.h / QwtPlot.cpp pair in src-amalgamate.
 *****************************************************************************/
 
#ifndef QWT_MATH_H
#define QWT_MATH_H
// stl
#include <iterator>
#include <type_traits>
#include <algorithm>
// qt
#include <QPointF>
#include <QtMath>
// qwt
#include "qwtcore_global.h"
/*
   Microsoft says:
 
   Define _USE_MATH_DEFINES before including math.h to expose these macro
   definitions for common math constants.  These are placed under an #ifdef
   since these commonly-defined names are not part of the C/C++ standards.
 */
 
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#define undef_USE_MATH_DEFINES
#endif
 
#include <cmath>
 
#ifdef undef_USE_MATH_DEFINES
#undef _USE_MATH_DEFINES
#undef undef_USE_MATH_DEFINES
#endif
 
#ifndef M_E
#define M_E (2.7182818284590452354)
#endif
 
#ifndef M_LOG2E
#define M_LOG2E (1.4426950408889634074)
#endif
 
#ifndef M_LOG10E
#define M_LOG10E (0.43429448190325182765)
#endif
 
#ifndef M_LN2
#define M_LN2 (0.69314718055994530942)
#endif
 
#ifndef M_LN10
#define M_LN10 (2.30258509299404568402)
#endif
 
#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif
 
#ifndef M_PI_2
#define M_PI_2 (1.57079632679489661923)
#endif
 
#ifndef M_PI_4
#define M_PI_4 (0.78539816339744830962)
#endif
 
#ifndef M_1_PI
#define M_1_PI (0.31830988618379067154)
#endif
 
#ifndef M_2_PI
#define M_2_PI (0.63661977236758134308)
#endif
 
#ifndef M_2_SQRTPI
#define M_2_SQRTPI (1.12837916709551257390)
#endif
 
#ifndef M_SQRT2
#define M_SQRT2 (1.41421356237309504880)
#endif
 
#ifndef M_SQRT1_2
#define M_SQRT1_2 (0.70710678118654752440)
#endif
 
#if defined(QT_WARNING_PUSH)
/*
    early Qt versions not having QT_WARNING_PUSH is full of warnings
    so that we do not care of suppressing those from below
 */
QT_WARNING_PUSH
QT_WARNING_DISABLE_CLANG("-Wdouble-promotion")
QT_WARNING_DISABLE_GCC("-Wdouble-promotion")
#endif
 
/*
    On systems, where qreal is a float you often run into
    compiler issues with qMin/qMax.
 */
 
constexpr inline float qwtMinF(float a, float b)
{
    return (a < b) ? a : b;
}
 
constexpr inline double qwtMinF(double a, double b)
{
    return (a < b) ? a : b;
}
 
constexpr inline qreal qwtMinF(float a, double b)
{
    return (a < b) ? a : b;
}
 
constexpr inline qreal qwtMinF(double a, float b)
{
    return (a < b) ? a : b;
}
 
constexpr inline float qwtMaxF(float a, float b)
{
    return (a < b) ? b : a;
}
 
constexpr inline double qwtMaxF(double a, double b)
{
    return (a < b) ? b : a;
}
 
constexpr inline qreal qwtMaxF(float a, double b)
{
    return (a < b) ? b : a;
}
 
constexpr inline qreal qwtMaxF(double a, float b)
{
    return (a < b) ? b : a;
}
 
#if defined(QT_WARNING_POP)
QT_WARNING_POP
#endif
 
QWTCORE_EXPORT double qwtNormalizeRadians(double radians);
QWTCORE_EXPORT double qwtNormalizeDegrees(double degrees);
QWTCORE_EXPORT quint32 qwtRand();
 
inline int qwtFuzzyCompare(double value1, double value2, double intervalSize)
{
    const double eps = qAbs(1.0e-6 * intervalSize);
 
    if (value2 - value1 > eps)
        return -1;
 
    if (value1 - value2 > eps)
        return 1;
 
    return 0;
}
 
inline int qwtSign(double x)
{
    if (x > 0.0)
        return 1;
    else if (x < 0.0)
        return (-1);
    else
        return 0;
}
 
inline constexpr double qwtSqr(double x)
{
    return x * x;
}
 
inline double qwtFastAtan(double x)
{
    if (x < -1.0)
        return -M_PI_2 - x / (x * x + 0.28);
 
    if (x > 1.0)
        return M_PI_2 - x / (x * x + 0.28);
 
    return x / (1.0 + x * x * 0.28);
}
 
inline double qwtFastAtan2(double y, double x)
{
    if (x > 0)
        return qwtFastAtan(y / x);
 
    if (x < 0) {
        const double d = qwtFastAtan(y / x);
        return (y >= 0) ? d + M_PI : d - M_PI;
    }
 
    if (y < 0.0)
        return -M_PI_2;
 
    if (y > 0.0)
        return M_PI_2;
 
    return 0.0;
}
 
inline constexpr double qwtCubicPolynomial(double x, double a, double b, double c, double d)
{
    return (((a * x) + b) * x + c) * x + d;
}
 
inline constexpr double qwtRadians(double degrees)
{
    return degrees * M_PI / 180.0;
}
 
inline constexpr double qwtDegrees(double degrees)
{
    return degrees * 180.0 / M_PI;
}
 
inline int qwtCeil(qreal value)
{
    using std::ceil;
    return int(ceil(value));
}
inline int qwtFloor(qreal value)
{
    using std::floor;
    return int(floor(value));
}
 
inline int qwtVerifyRange(int size, int& i1, int& i2)
{
    if (size < 1)
        return 0;
 
    i1 = qBound(0, i1, size - 1);
    i2 = qBound(0, i2, size - 1);
 
    if (i1 > i2)
        qSwap(i1, i2);
 
    return (i2 - i1 + 1);
}
 
inline double qwtDistance(const QPointF& p1, const QPointF& p2)
{
    double dx = p2.x() - p1.x();
    double dy = p2.y() - p1.y();
    return qSqrt(dx * dx + dy * dy);
}
 
template< typename T >
inline typename std::enable_if< std::is_floating_point< T >::value, bool >::type qwt_is_nan_or_inf(const T& value)
{
    return !std::isfinite(value);
}
 
inline bool qwt_is_nan_or_inf(const QPointF& point)
{
    return !std::isfinite(point.x()) || !std::isfinite(point.y());
}
 
// Default check function - for other types
template< typename T >
typename std::enable_if< !std::is_floating_point< T >::value && !std::is_same< T, QPointF >::value,
                         bool >::type inline qwt_is_nan_or_inf(const T& /*value*/)
{
    return false;
}
 
template< typename InputIt >
inline bool qwtContainsNanOrInf(InputIt first, InputIt last)
{
    // Iterate using iterator, calling the appropriate qwt_is_nan_or_inf function for each element
    for (InputIt it = first; it != last; ++it) {
        if (qwt_is_nan_or_inf(*it)) {
            return true;
        }
    }
    return false;
}
 
template< typename Container >
inline std::size_t qwtRemoveNanOrInf(Container& container)
{
    // Use std::remove_if algorithm to move retained elements to the front of the container
    auto new_end = std::remove_if(container.begin(), container.end(), [](const typename Container::value_type& value) {
        return qwt_is_nan_or_inf(value);
    });
 
    // Calculate the number of removed elements
    std::size_t removed_count = std::distance(new_end, container.end());
 
    // Actually erase the unwanted elements
    if (removed_count > 0) {
        container.erase(new_end, container.end());
    }
 
    return removed_count;
}
 
template< typename Container >
inline Container qwtRemoveNanOrInfCopy(const Container& container)
{
    Container result;
    result.reserve(container.size());  // pre-allocate for efficiency
 
    // Copy only elements that are not NaN or Inf
    std::copy_if(container.begin(),
                 container.end(),
                 std::back_inserter(result),
                 [](const typename Container::value_type& value) { return !qwt_is_nan_or_inf(value); });
 
    return result;
}
 
template< typename It1, typename It2 >
bool fuzzyRangeEqual(It1 first1, It1 last1, It2 first2, It2 last2)
{
    // 1. Different lengths => not equal
    if (std::distance(first1, last1) != std::distance(first2, last2))
        return false;
 
    // 2. Element-wise qFuzzyCompare
    for (; first1 != last1; ++first1, ++first2) {
        if (!qFuzzyCompare(*first1, *first2))
            return false;
    }
    return true;
}
 
#endif