numerics.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef NUMERICS_H
#define NUMERICS_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "math_global.h"
 
#include <string>
#include <utility>
#include <vector>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QVariant>
 
//=============================================================================================================
// DEFINE NAMESPACE UTILSLIB
//=============================================================================================================
 
namespace UTILSLIB
{
 
//=============================================================================================================
class MATHSHARED_EXPORT Numerics
{
public:
    //=========================================================================================================
    ~Numerics() = default;
 
    //=========================================================================================================
    static int gcd(int iA, int iB);
 
    //=========================================================================================================
    static bool issparse(Eigen::VectorXd &v);
 
    //=========================================================================================================
    static int nchoose2(int n);
 
    //=========================================================================================================
    static Eigen::MatrixXd rescale(const Eigen::MatrixXd &data,
                                   const Eigen::RowVectorXf &times,
                                   const QPair<float, float> &baseline,
                                   QString mode);
 
    //=========================================================================================================
    static Eigen::MatrixXd rescale(const Eigen::MatrixXd& data,
                                   const Eigen::RowVectorXf& times,
                                   const std::pair<float, float>& baseline,
                                   const std::string& mode);
 
    //=========================================================================================================
    template<typename T>
    static inline double log2(const T d);
 
    //=========================================================================================================
    template<typename T>
    static void histcounts(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& matRawData,
                           bool bMakeSymmetrical,
                           int iClassAmount,
                           Eigen::VectorXd& vecResultClassLimits,
                           Eigen::VectorXi& vecResultFrequency,
                           double dGlobalMin = 0.0,
                           double dGlobalMax = 0.0);
 
    template<typename T>
    static void histcounts(const Eigen::Matrix<T, Eigen::Dynamic, 1>& matRawData,
                           bool bMakeSymmetrical,
                           int iClassAmount,
                           Eigen::VectorXd& vecResultClassLimits,
                           Eigen::VectorXi& vecResultFrequency,
                           double dGlobalMin = 0.0,
                           double dGlobalMax = 0.0);
 
    template<typename T>
    static void histcounts(const Eigen::Matrix<T, 1, Eigen::Dynamic>& matRawData,
                           bool bMakeSymmetrical,
                           int iClassAmount,
                           Eigen::VectorXd& vecResultClassLimits,
                           Eigen::VectorXi& vecResultFrequency,
                           double dGlobalMin = 0.0,
                           double dGlobalMax = 0.0);
};
 
//=============================================================================================================
// INLINE & TEMPLATE DEFINITIONS
//=============================================================================================================
 
template<typename T>
inline double Numerics::log2(const T d)
{
    return log(d)/log(2);
}
 
//=============================================================================================================
 
template<typename T>
void Numerics::histcounts(const Eigen::Matrix<T, Eigen::Dynamic, 1>& matRawData,
                          bool bMakeSymmetrical,
                          int iClassAmount,
                          Eigen::VectorXd& vecResultClassLimits,
                          Eigen::VectorXi& vecResultFrequency,
                          double dGlobalMin,
                          double dGlobalMax)
{
    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> matrixName(matRawData.rows(), 1);
    matrixName.col(0) = matRawData;
    Numerics::histcounts(matrixName, bMakeSymmetrical, iClassAmount, vecResultClassLimits, vecResultFrequency, dGlobalMin, dGlobalMax);
}
 
//=============================================================================================================
 
template<typename T>
void Numerics::histcounts(const Eigen::Matrix<T, 1, Eigen::Dynamic>& matRawData,
                          bool bMakeSymmetrical,
                          int iClassAmount,
                          Eigen::VectorXd& vecResultClassLimits,
                          Eigen::VectorXi& vecResultFrequency,
                          double dGlobalMin,
                          double dGlobalMax)
{
    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> matrixName(1, matRawData.cols());
    matrixName.row(0) = matRawData;
    Numerics::histcounts(matrixName, bMakeSymmetrical, iClassAmount, vecResultClassLimits, vecResultFrequency, dGlobalMin, dGlobalMax);
}
 
//=============================================================================================================
 
template<typename T>
void Numerics::histcounts(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& matRawData,
                          bool bMakeSymmetrical,
                          int iClassAmount,
                          Eigen::VectorXd& vecResultClassLimits,
                          Eigen::VectorXi& vecResultFrequency,
                          double dGlobalMin,
                          double dGlobalMax)
{
    if(matRawData.rows() == 0 || matRawData.cols() == 0) {
        return;
    }
 
    vecResultClassLimits.resize(iClassAmount + 1);
    vecResultFrequency.resize(iClassAmount);
 
    for (int count = 0; count < iClassAmount; ++count)
    {
        vecResultFrequency(count) = 0;
    }
 
    double desiredMin,
           desiredMax;
    double rawMin(0.0),
           rawMax(0.0),
           localMin(0.0),
           localMax(0.0);
 
    rawMin = matRawData.minCoeff();
    rawMax = matRawData.maxCoeff();
 
    if (bMakeSymmetrical == true)
    {
        if (std::fabs(rawMin) > rawMax)
        {
            localMax = std::fabs(rawMin);
            localMin = rawMin;
        }
        else if (rawMax > std::fabs(rawMin))
        {
            localMin = -(rawMax);
            localMax = rawMax;
        }
        else
        {
            localMin = rawMin;
            localMax = rawMax;
        }
    }
    else
    {
        localMin = rawMin;
        localMax = rawMax;
    }
 
    if (dGlobalMin == 0.0 && dGlobalMax == 0.0)
    {
        desiredMin = localMin;
        desiredMax = localMax;
        vecResultClassLimits[0] = desiredMin;
        vecResultClassLimits[iClassAmount] = desiredMax;
    }
    else
    {
        desiredMin = dGlobalMin;
        desiredMax = dGlobalMax;
        vecResultClassLimits(0) = desiredMin;
        vecResultClassLimits(iClassAmount) = desiredMax;
    }
 
    double range = (vecResultClassLimits(iClassAmount) - vecResultClassLimits(0)),
           dynamicUpperClassLimit;
 
    for (int kr = 0; kr < iClassAmount; ++kr)
    {
        dynamicUpperClassLimit = (vecResultClassLimits(0) + (kr * (range / iClassAmount)));
        vecResultClassLimits(kr) = dynamicUpperClassLimit;
    }
 
    for (int ir = 0; ir < matRawData.rows(); ++ir)
    {
        for (int jr = 0; jr < matRawData.cols(); ++jr)
        {
            if(matRawData(ir,jr) != 0.0) {
                for (int kr = 0; kr < iClassAmount; ++kr)
                {
                    if (kr == iClassAmount - 1)
                    {
                        if (matRawData(ir,jr) >= vecResultClassLimits(kr) && matRawData(ir,jr) <= vecResultClassLimits(kr + 1))
                        {
                            vecResultFrequency(kr) = vecResultFrequency(kr) + 1;
                        }
                    }
                    else
                    {
                        if (matRawData(ir,jr) >= vecResultClassLimits(kr) && matRawData(ir,jr) < vecResultClassLimits(kr + 1))
                        {
                            vecResultFrequency(kr) = vecResultFrequency(kr) + 1;
                        }
                    }
                }
            }
        }
    }
}
 
//=============================================================================================================
} // NAMESPACE
 
#endif // NUMERICS_H