algo.h

#ifndef ALGO_H
#define ALGO_H
 
 
#include "platform_global.h"
#include <memoryheap.h>
#include <QDateTime>
#include <QVariant>
#include <QVariantList>
#include <QString>
#include <QtAlgorithms>
#include <random>
#include <QDateTime>
 
 
#include <math.h>
#include <complex>
 
typedef std::complex<double> CPLX;
 
#define        THRESHOLD    1E-6
#define        MAXVAL       1.0E38
 
enum COMPOSITION { PEAK, INTEGRATE, PEAK_AVG, TROUGH };
 
namespace algo {
 
template <typename InputIterator, typename OutputIterator>
inline OutputIterator vCopy(InputIterator begin, InputIterator end, OutputIterator dest)
{
    while (begin != end)
        *dest++ = *begin++;
    return dest;
}
 
template <typename BiIterator1, typename BiIterator2>
inline BiIterator2 vCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest)
{
    while (begin != end)
        *--dest = *--end;
    return dest;
}
 
template <typename InputIterator1, typename InputIterator2>
inline bool vEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
{
    for (; first1 != last1; ++first1, ++first2)
        if (!(*first1 == *first2))
            return false;
    return true;
}
 
 
template <class T>
void VCast( const VremVArray &si1, T *dst)
{
    int i;
    for( i = 0; i < si1.size(); ++i)
    {
        dst[i] = si1[i].value<T>();
    }
}
 
 
template <class T>
void VCast( const QVariantList &si1, T *dst)
{
    int i;
    for( i = 0; i < si1.size(); ++i)
    {
        dst[i] = si1[i].value<T>();
    }
}
 
 
template <typename ForwardIterator, typename T>
inline void  vFill(ForwardIterator first, ForwardIterator last, const T &val)
{
    for (; first != last; ++first)
        *first = val;
}
 
 
template <typename Container, typename T>
inline void vFill(Container &container, const T &val)
{
    vFill(container.begin(), container.end(), val);
}
 
 
class PLATFORMSHARED_EXPORT smath
{
public :
  static QVariant DefaultValue(
      QString key,
      QVariant src,
      QVariant defaultValue = "",
      bool ignorKeyCase = true);
 
  static QVariant DefaultValue(
      QString key,
      VremVArray src,
      QVariant defaultValue = "",
      bool ignorKeyCase = true);
 
  static QVariant DefaultValue(
      QString key,
      VremList src,
      QVariant defaultValue = "",
      bool ignorKeyCase = true);
 
  static bool Contains(QString pattern, QVariant src, bool ignorKeyCase = true);
 
  static QVariant Normalize(const QString str );
 
};
 
class PLATFORMSHARED_EXPORT vmath
{
public :
 
   typedef struct
       {
       double Y_SUM;          /* used interally */
       double X_SUM;          /* used interally */
       double N;              /* used interally */
       double XY_SUM;         /* used interally */
       double X_SQ_SUM;       /* used interally */
       double Y_SQ_SUM;       /* used interally */
 
       double slope;          /* can be used by caller after regression_a() */
       double intercept;      /* can be used by caller after regression_a() */
       double correlation;    /* can be used by caller after regression_a() */
 
   } REGRESSION;
 
    static void Inc(VremVArray &i1, int count = -1, int index = 0);
 
    static void Dec(VremVArray &i1, int count = -1, int index = 0);
 
    static void Atan(VremVArray &i1,int count = -1, int index = 0);
 
    static void AtanH(VremVArray &i1,int count = -1,int index = 0);
 
    static void Cos(VremVArray &i1, int count = -1, int index = 0);
 
    static void CosH(VremVArray &i1,int count = -1, int index = 0);
 
    static void ACos(VremVArray &i1,int count = -1, int index = 0);
 
    static void Sin(VremVArray &i1, int count = -1, int index = 0);
 
    static void SinH(VremVArray &i1,int count = -1, int index = 0);
 
    static void Tan(VremVArray &i1, int count = -1, int index = 0);
 
    static void TanH(VremVArray &i1,int count = -1, int index = 0);
 
 
    static void Log(VremVArray &i1, int count = -1, int index = 0);
 
    static void Exp(VremVArray &i1, int count = -1, int index = 0);
 
    static void Sqrt(VremVArray &i1,int count = -1, int index = 0);
 
    static void Fabs(VremVArray &i1,int count = -1, int index = 0);
 
    static void Floor(VremVArray &i1,int count = -1, int index = 0);
 
    static void Rev(VremVArray &i1, int index = 0);
 
    static void Rrl(VremVArray &i1, int index = 0);
 
    static void Rrr(VremVArray &i1, int index = 0);
 
    static void Fill(VremVArray &i1, QVariant with, int count = -1, int index = 0);
 
    static QVariant Highest( const VremVArray &i1, int count = -1, int index = 0);
 
    static QVariant Highest( const VremVArray &i1,  QVariant except, int count = -1, int index = 0);
 
    static QVariant Lowest( const VremVArray &i1, int count = -1, int index = 0);
 
    static QVariant Lowest( const VremVArray &i1,  QVariant except, int count = -1, int index = 0);
 
    static QVariant Mean ( const VremVArray &i1, int count = -1, int index = 0);
 
    static QVariant Mean ( const VremVArray &i1,  QVariant except, int count = -1, int index = 0);
 
    static QVariant Mean ( const QVariantList &i1, int count = -1, int index = 0);
 
    static QVariant Mean ( const QVariantList &i1,  QVariant except, int count = -1, int index = 0);
 
 
    static QVariant Sum ( const VremVArray &i1, int count = -1, int index = 0);
 
    static QVariant Sum ( const VremVArray &i1,  QVariant except, int count = -1, int index = 0);
 
    static void Balance(
            VremVArray &d1  ,           // destination double array
            const VremVArray &s1    // source double array
            , int count = -1
            , int index = 0);
 
    static void Mask(
            VremVArray &d1              // destination double array
            ,const VremVArray &s1   // source double array
            ,int countDst = -1
            ,int indexDst = 0
            ,int countSrc = -1
            ,int indexSrc = 0
            );
 
     static int getRand(int min, int max){
        unsigned int ms = static_cast<unsigned>(QDateTime::currentMSecsSinceEpoch());
        std::mt19937 gen(ms);
        std::uniform_int_distribution<> uid(min, max);
        return uid(gen);
    }
 
 
    static QVariant ComputerVar ( const VremVArray &i1,    int count = -1, int index = 0);
 
    static QVariant ComputerVarNZ ( const VremVArray &i1,  int count = -1, int index = 0);
 
    static void AlignL(
           VremVArray &d,           // destination double array
           const VremVArray &s  // source double array
            );
 
    static int check_bounds(double left, double right, int start, int end, int invert );
 
    static bool map_doubles    (
            double    d[], /* destination double array */
            double s[],  /* source double array */
            int d_count, /* d element count */
            int start_s, /* s boundaries */
            int end_s,
            int left_s,
            int right_s,
            double offst,
            double total_s_width,
            double min_d_width,
            double d_width[], /* zone size array in multiples of min_d_width */
            COMPOSITION composition,
            bool edge_allow_0,
            bool middle_allow_0
            );
 
    static void MapIt(
            VremVArray &d,          // destination double array
            const VremVArray &s );
 
    static void FFT(VremVArray &s);
 
    static bool IdenticalArray(const VremVArray i1, const VremVArray i2);
 
    static QByteArray ConvertToStream( const VremVArray &i1);
 
 
    static VremVArray ConvertToVremVArray(QByteArray &stream);
 
    static VremVArray ConvertToVremVArray(QVariantList &lst);
 
    static QVariantList ConvertToQVariantList(QByteArray &stream);
 
    static QVariantList ConvertToQVariantList(VremVArray &varray);
 
    template <class T>
    static void displayPointer ( T *ptr )
    {
 
      QString ptrStr = QString("0x%1").arg(  reinterpret_cast<quintptr>(ptr),
                          QT_POINTER_SIZE * 2, 16, QChar('0'));
      qDebug() << ptrStr;
    }
 
 
 
static QVariant
pow_xy(
    QVariant x,
    int rs
      )
{
    double temp = x.toDouble();
 
    while (--rs >= 1)
    {
        temp = temp * x.toDouble();
    }
    return(temp);
}
 
QVariant poly(QVariant x, int degree, QVariantList coeff)
{
    double value;
 
    value = 0;
 
    while (degree)
    {
        value = value + (coeff[degree].toDouble() * algo::vmath::pow_xy(x, degree).toDouble());
        degree--;
    }
 
    value = value + coeff[degree].toDouble();
    return(value);
}
 
 
 
 
static void
    regression_clear(REGRESSION *rg);
 
    static void
    regression_accumulator(REGRESSION *rg, double x, double y);
 
    static void
    regression_compute(REGRESSION *rg);
 
 
    static void
    correlation_compute(REGRESSION *rg);
 
 
    /*-------------------------------------------------------------------------
    --.i.regression_a
    --    Computes linear regression of x and y variables
    --
    --    Where *rg     = setpoint            (REGRESSION *)
    --          *x    = x values            (double *)
    --          *y    = y values            (double *)
    --          count    = points to plot        (int )
    --
    --    Returns Void
    --
    --    Created by:    EWC    11.July.1989
    --------------------------------------------------------------------------*/
 
    static void
    regression_a
        (
        REGRESSION *rg,        /* regression structure */
        double *x,        /* x values */
        double *y,        /* y values corresponding to the x values */
        int count        /* number of points to plot */
        );
 
};
 
 
class PLATFORMSHARED_EXPORT DbxDistributionFilter
{
#define EPSILON 1E-6
 
protected :
     typedef enum
     {
          Forward,  
          Reverse   
     }
     Direction;
 
     Direction direction;
 
     bool WaitForFirst;
 
     bool WaitForValue;
 
     double VAxisStep;
 
     double StartVAxis;
 
     double TotalValue;
 
     double LastVAxis;
 
public:
     DbxDistributionFilter ( QVariant stepSize = static_cast<double>(1.0) );   // DbxDistributionFilter
 
     DbxDistributionFilter ( const DbxDistributionFilter &ref );   // DbxDistributionFilter
 
     virtual ~ DbxDistributionFilter() {}
 
     QVariant step ( void )
     {
          return VAxisStep;
     }   // step
 
 
     bool setStep ( QVariant stepSize );   // setStep
 
 
     bool forward ( void ) { return direction == Forward; }
 
     void setDirection( DbxDistributionFilter::Direction dir = Forward );
 
     virtual bool insertValue ( const QVariant v, const QVariant vA);
 
     virtual bool insertAValue ( const QVariant v );   // insertValue
 
     virtual void flushValue ( void );   // flushValue
 
     virtual void interpolatedValue ( const QVariant value, const QVariant vAxis )
     {
       Q_UNUSED ( value )
       Q_UNUSED ( vAxis )
     }
 
 
};  // DbxDistributionFilter
 
class PLATFORMSHARED_EXPORT  MeanAverage {
 
private :
    QVarLengthArray<int> N;
    VremVArray array;
public :
    MeanAverage()
    {
    }
 
    void Reset()
    {
        array.clear();
        N.clear();
    }
 
    VremVArray GetValues()
    {
        return array;
    }
 
    VremVArray GetMean()
    {
        VremVArray mean( array.size());
        for( int i = 0; i < array.size() && i < mean.size() && i < N.size(); ++i)
        {
            int NN = N[i];
            if( NN )
                mean[i] = array[i].toDouble() / static_cast<double>(NN);
            else
                mean[i] = 0;
        }
        return mean;
    }
 
    void AddValues( VremVArray &v)
    {
        if( !N.size())
        {
            array = v;
            N.reserve(v.size());
            N.resize(v.size());
            std::fill(N.begin(), N.end(), static_cast<int>(1));
           // qFill(N,1);
 
        }
        else
        {
 
 
           for( int i = 0; i < v.size(); ++i)
           {
                if( i < array.size() && i < N.size())
                {
                    N[i] = N[i] + 1;
                    array[i] = array[i].toDouble() + v[i].toDouble();
                }
                else
                {
                    array.push_back(v[i]);
                    N.push_back(1);
                }
           }
        }
    }
};
 
template <class T>
class SUMMER
{
private:
    int _N;
    T Sum;
public:
    SUMMER() : _N(0), Sum( 0)
    {}
 
    SUMMER &operator+= (T v)
    {
        _N++;
        Sum += v;
        return *this;
    }
 
    void Reset() {
        _N = 0;
        Sum = 0;
    }
    T SumOf( void) {
        return Sum;
    }
    int N(void)
    {
        return _N;
    }
 
    T Mean( )
    {
        if( _N)
        {
            return Sum / static_cast<T>(_N);
        }
        return  0;
    }
 
 
};
 
class VremMask
{
private :
    QStringList listOfMySubnet;
 
public:
 
    VremMask( QString ip, QString mask)
    {
 
       int network, broadcast, range;
       QString  NetworkAddress, BroadCastAddress;
 
       QString IpAddress = ip;
       QString NetMask = mask;
 
       int cIP = IpAddress.lastIndexOf('.');
 
       int nMsk = NetMask.lastIndexOf('.');
 
       if ( cIP == -1 || nMsk == -1)
       {
          range = 1;
          network = 0;
          broadcast = 255;
       }
 
       int cMask = NetMask.mid(nMsk + 1).toInt();
       int classC = IpAddress.mid(cIP + 1).toInt();
 
       QString classB = NetworkAddress = BroadCastAddress = IpAddress.left(cIP + 1);
 
       if ( cMask == 0)
       {
          range = 256; 
          network = 0;
          broadcast = 255;
       }
       else
       {
          range = (255 - cMask) + 1; 
          network = (classC & cMask) & 0xff;  
          broadcast = network + (range -1);   
       }
       {
          QVariant v(broadcast);
          BroadCastAddress +=  v.toString();
       }
 
       {  
          QVariant v(network);
          NetworkAddress += v.toString();
       }
 
       for ( int i = network; i < network + range; ++ i)
       {
          QVariant v(i);
          QString ipInSubnet  = classB + v.toString();
          listOfMySubnet.push_back(ipInSubnet);
 
       }
    }
 
 
    const QStringList SubNet(void)
    {
        return listOfMySubnet;
    }
 
    const QString Network(void)
 
    {
        if (listOfMySubnet.size() )
            return listOfMySubnet[0];
        return "localhost";
    }
 
    const QString BroadCast(void)
    {
        if (listOfMySubnet.size() )
            return listOfMySubnet[listOfMySubnet.size() -1 ];
 
        return "localhost";
    }
 
    static const QStringList  ListOfSubnetAddresses( QString ip, QString mask)
    {
        VremMask v( ip, mask);
        return v.SubNet();
    }
};  
 
}
 
 
#endif // ALGO_H