Vector.h

Go to the documentation of this file.

#if !defined(__VectorFloat_hdr__)
#define __VectorFloat_hdr__
 
#include <cassert>
#include <cstring>
#include <limits>
#include <cmath>
 
class CVector
{
public:
    template<typename T>
    static void setZero (T *pfSrcDest, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
 
        if (iLength > 0)
            memset (pfSrcDest, 0, sizeof(T)*iLength);
    }
    template<typename T>
    static void setZeroBelowThresh (T *pfSrcDest, int iLength, T Thresh)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
 
        for (int i = 0; i < iLength; i++)
            if (pfSrcDest[i] < Thresh)
                pfSrcDest[i] = 0;
    }
    template<typename T>
    static void copy(T *pDest, const T *pSource, int iLength)
    {
        assert(iLength >= 0);
 
        if (iLength > 0)
        {
            assert(pDest);
            assert(pSource);
            memcpy(pDest, pSource, sizeof(T)*iLength);
        }
    }
    template<typename T>
    static void flip_I(T *pfSrcDest, int iLength)
    {
        assert(iLength >= 0);
 
        if (iLength > 0)
        {
            assert(pfSrcDest);
 
            int iLoopLength = iLength / 2; // integer division!
            for (int i = 0; i < iLoopLength; i++)
            {
                T Tmp                       = pfSrcDest[i];
                pfSrcDest[i]                 = pfSrcDest[iLength - 1 - i];
                pfSrcDest[iLength - 1 - i]   = Tmp;
            }
        }
    }
    template<typename T>
    static void moveInMem (T *pfSrcDest, int iDestIdx, int iSrcIdx, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
 
        if (iLength > 0)
            memmove (&pfSrcDest[iDestIdx], &pfSrcDest[iSrcIdx], sizeof(T)*iLength);
    }
};
 
class CVectorFloat
{
public:
 
    static inline void setZero (float *pfSrcDest, int iLength)
    {
        CVector::setZero(pfSrcDest, iLength);
    }
    
    static inline void setZeroBelowThresh (float *pfSrcDest, int iLength, float fThresh)
    {
        CVector::setZeroBelowThresh(pfSrcDest, iLength, fThresh);
    }
 
    static inline void copy(float *pfDest, const float *pfSource, int iLength)
    {
        CVector::copy(pfDest, pfSource, iLength);
    }
 
    static inline void flip_I(float *pfSrcDest, int iLength)
    {
        CVector::flip_I(pfSrcDest, iLength);
    }
 
    static inline void moveInMem (float *pfSrcDest, int iDestIdx, int iSrcIdx, int iLength)
    {
        CVector::moveInMem(pfSrcDest, iDestIdx, iSrcIdx, iLength);
    }
 
    static inline void setValue (float *pfDest, float fValue, int iLength)
    {
        assert (iLength >= 0);
        assert (pfDest);
 
        for (int i = 0; i < iLength; i++)
            pfDest[i] = fValue;
    }
 
    static inline void mulC_I (float *pfSrcDest, float fScale, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
        
        for (int i = 0; i < iLength; i++)
            pfSrcDest[i] *= fScale;
    }
 
    static inline void mul_I (float *pfSrcDest, const float *pfSrc, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
        assert (pfSrc);
 
        for (int i = 0; i < iLength; i++)
            pfSrcDest[i] *= pfSrc[i];
    }
 
    static inline float mulScalar (const float *pfSrc1, const float *pfSrc2, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrc1);
        assert (pfSrc2);
        float  fResult = 0;
 
        for (int i = 0; i < iLength; i++)
            fResult += pfSrc1[i] * pfSrc2[i];
 
        return fResult;
    }
 
    static inline void div_I (float *pfSrcDest, const float *pfSrc, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
        assert (pfSrc);
 
        for (int i = 0; i < iLength; i++)
        {
            assert(pfSrc[i] != 0);
            pfSrcDest[i] /= pfSrc[i];
        }
    }
 
    static inline void add_I (float *pfSrcDest, const float *pfSrc, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
        assert (pfSrc);
 
        for (int i = 0; i < iLength; i++)
            pfSrcDest[i] += pfSrc[i];
    }
 
    static inline void addC_I (float *pfSrcDest, float fScale, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
 
        for (int i = 0; i < iLength; i++)
            pfSrcDest[i] += fScale;
    }
 
    static inline void sub_I (float *pfSrcDest, const float *pfSrc, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrcDest);
        assert (pfSrc);
 
        for (int i = 0; i < iLength; i++)
            pfSrcDest[i] -= pfSrc[i];
    }
 
    static inline float sum (const float *pfSrc, int iLength, bool bAbs = false)
    {
        assert (iLength >= 0);
        assert (pfSrc);
 
        float fResult = 0;
        if (bAbs)
        {
            for (int i = 0; i < iLength; i++)
                fResult += std::abs(pfSrc[i]);
        }
        else
        {
            for (int i = 0; i < iLength; i++)
                fResult += pfSrc[i];
        }
        return fResult;
    }
 
    static inline bool isEqual (const float *pfSrc1, const float *pfSrc2, int iLength)
    {
        assert (iLength >= 0);
        assert (pfSrc1);
        assert (pfSrc2);
 
        return (memcmp (pfSrc1, pfSrc2, iLength * sizeof(float)) == 0);
    }
 
    static inline float getMean (const float *pfSrc, long long int iLength)
    {
        assert (iLength >= 0);
 
        float fMean = 0;
 
        for (int i=0; i < iLength; i++)
        {
            fMean  += pfSrc[i];
        }
 
        if (iLength > 0)
        {
            fMean  /= iLength;
        }
 
        return fMean;
    }
 
    static inline float getStd (const float *pfSrc, long long int iLength, float fMean = std::numeric_limits<float>::max())
    {
        assert (iLength >= 0);
 
        float  fStd = 0;
 
        if (fMean == std::numeric_limits<float>::max())
        {
            fMean   = getMean(pfSrc, iLength);
        }
 
        for (int i=0; i < iLength; i++)
        {
            fStd   += (pfSrc[i] - fMean) * (pfSrc[i] - fMean);
        }
 
        if (iLength > 1)
        {
            //dStd   /= (iLength - 1);
            fStd   /= iLength;
        }
 
        return std::sqrt(fStd);
    }
 
    static inline float getRms (const float *pfSrc, long long int iLength)
    {
        assert (iLength >= 0);
 
        float fRms = 0;
 
 
        for (int i=0; i < iLength; i++)
        {
            fRms   += pfSrc[i] * pfSrc[i];
        }
 
        if (iLength > 0)
        {
            fRms   /= iLength;
        }
 
        return std::sqrt(fRms);
    }
 
    static inline float getMax (const float *pfSrc, long long int iLength, bool bAbs = false)
    {
        float fMax;
        long long iMax;
 
        findMax(pfSrc, fMax, iMax, iLength, bAbs);
 
        return fMax;
    }
 
    static inline float getMin (const float *pfSrc, long long int iLength, bool bAbs = false)
    {
        float fMin;
        long long iMin;
 
        findMin(pfSrc, fMin, iMin, iLength, bAbs);
 
        return fMin;
    }
 
    static inline void findMax (const float *pfSrc, float &fMax, long long &iMax, long long int iLength, bool bAbs = false)
    {
        assert (iLength >= 0);
        assert (pfSrc);
 
        fMax    = -std::numeric_limits<float>::max();
        iMax    = -1;
 
        for (int i = 0; i < iLength; i++)
        {
            float fCurr   = (bAbs)? std::abs(pfSrc[i]) : pfSrc[i];
 
            if (fCurr > fMax)
            {
                fMax = fCurr;
                iMax = i;
            }
        }
    }
 
    static inline void findMin (const float *pfSrc, float &fMin, long long &iMin, long long int iLength, bool bAbs = false)
    {
        assert (iLength >= 0);
        assert (pfSrc);
 
        fMin    = std::numeric_limits<float>::max();
        iMin    = -1;
 
        for (int i = 0; i < iLength; i++)
        {
            float fCurr   = (bAbs)? std::abs(pfSrc[i]) : pfSrc[i];
 
            if (fCurr < fMin)
            {
                fMin    = fCurr;
                iMin    = i;
            }
        }
    }
};
#endif // __VectorFloat_hdr__