FEAPIExamplePluginZeroCrossings/zplVecLibGen.cpp

Go to the documentation of this file.

//     /*! \file zplVecLibGen.cpp: \brief implementation of the zplVecLib generic functions. */
//
//        Copyright (c) 2004-2007  
//        zplane.development
//        Flohrer Lerch Schwerdtfeger GbR
//        All rights reserved.
//
//        Redistribution and use in source and binary forms, with or without 
//        modification, are permitted provided that the following conditions 
//        are met:
//
//        *   Redistributions of source code must retain the above copyright 
//            notice, this list of conditions and the following disclaimer. 
//        *   Redistributions in binary form must reproduce the above 
//            copyright notice, this list of conditions and the following 
//            disclaimer in the documentation and/or other materials 
//            provided with the distribution. 
//        *   Neither the name of the FEAPI development team nor the names 
//            of its contributors may be used to endorse or promote products 
//            derived from this software without specific prior written 
//            permission. 
//
//        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
//        "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
//        LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
//        FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
//        COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
//        INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
//        BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
//        LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
//        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
//        LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
//        ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
//        POSSIBILITY OF SUCH DAMAGE.
//

#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "zplVecLib.h"

#ifndef ZABS
#define ZABS(a)                 (((a) > (0)) ? (a) : -(a))
#endif

float*   zplfMalloc_Gen      (int       iNumOfFloats)
{
    ZASSERT (iNumOfFloats <= 0);
    
    return ((float*) malloc (iNumOfFloats * sizeof(float)));
}


void       zplfFree_Gen        (float   *&ppfBuffer)
{
    ZASSERT (&ppfBuffer == 0 || ppfBuffer == 0);

    free (ppfBuffer);
    ppfBuffer   = 0;

    return;
}


void       zplfSetZero_Gen     (float   *pfBuffer, int iLengthAsPowOf4)
{
    ZASSERT (pfBuffer == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    if (iLengthAsPowOf4 == 0)
        return;

    memset (pfBuffer, 0, sizeof (float) * iLengthAsPowOf4);
    return;
}


void       zplfRealFindMax_Gen   (float    *pfSrc, float    *pfMax, int    *piIdx, int    iLengthAsPowOf4)
{
    ZASSERT (pfSrc == 0 || pfMax == 0 || piIdx == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
    
    *piIdx = 0;
    *pfMax  = -1e37F;

    for (int i = 0; i < iLengthAsPowOf4; i++)
    {
        if (pfSrc[i] >= *pfMax)
        {
            *pfMax  = pfSrc[i];
            *piIdx  = i;
        }
    }
    return;
}

void       zplfRealAdd_I_Gen   (float   *pfSrcDest, float    *pfSrc, int    iLengthAsPowOf4)
{
    ZASSERT (pfSrc == 0 || pfSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
        pfSrcDest[i]   += pfSrc[i];

    return;
}

void       zplfRealAddC_I_Gen   (float   *pfSrcDest, float    fValue, int    iLengthAsPowOf4)
{
    ZASSERT (pfSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
        pfSrcDest[i]   += fValue;

    return;
}

void       zplfRealSub_I_Gen   (float   *pfSrcDest, float    *pfSrc, int    iLengthAsPowOf4)
{
    ZASSERT (pfSrc == 0 || pfSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
        pfSrcDest[i]   -= pfSrc[i];

    return;
}


void       zplfRealMul_I_Gen   (float   *pfSrcDest, float    *pfSrc, int    iLengthAsPowOf4)
{
    ZASSERT (pfSrc == 0 || pfSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
        pfSrcDest[i]   *= pfSrc[i];

    return;
}

void       zplfRealMulC_I_Gen  (float   *pfSrcDest, float    fScaleFactor, int    iLengthAsPowOf4)
{
    ZASSERT (pfSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
        pfSrcDest[i]   *= fScaleFactor;

    return;
}

void       zplfRealDiv_I_Gen   (float   *pfNomSrcDest, float    *pfDenomSrc, int    iLengthAsPowOf4)
{
    ZASSERT (pfDenomSrc == 0 || pfNomSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
    {
        ZASSERT (pfDenomSrc[i] == 0);
        pfNomSrcDest[i]   /= pfDenomSrc[i];
    }

    return;
}


void       zplfRealMac_I_Gen   (float   *pfSrcDest, float    *pfSrc1, float   *pfSrc2, int   iLengthAsPowOf4)
{
    ZASSERT (pfSrc1 == 0 || pfSrc2 == 0 || pfSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
        pfSrcDest[i]   += pfSrc1[i] * pfSrc2[i];

    return;
}


void       zplfRealAbs_I_Gen   (float   *pfSrcDest, int iLengthAsPowOf4)
{
    ZASSERT (pfSrcDest == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i++)
        pfSrcDest[i]    = ZABS(pfSrcDest[i]);

    return;
}


float    zplfRealSum_Gen   (float   *pfSrc, int iLengthAsPowOf4)
{
    float fResult = 0;
    ZASSERT (pfSrc == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    for (int i = 0; i < iLengthAsPowOf4; i+=4)
    {
        fResult += pfSrc[i];
        fResult += pfSrc[i+1];
        fResult += pfSrc[i+2];
        fResult += pfSrc[i+3];
    }
    return fResult;
}


void       zplfCompAdd_I_Gen   (zCOMPLEX   *pfSrcDest, zCOMPLEX    *pfSrc,  int iRealLengthAsPowOf4)
{
    zplfRealAdd_I (pfSrcDest, pfSrc, (iRealLengthAsPowOf4<<1));
}


void       zplfCompMul_I_Gen   (zCOMPLEX   *pfSrcDest, zCOMPLEX    *pfSrc,  int iRealLengthAsPowOf4)
{
    ZASSERT (1); 
}


void       zplfCompDiv_I_Gen   (zCOMPLEX   *pfNomSrcDest, zCOMPLEX    *pfDenomSrc, int    iRealLengthAsPowOf4)
{
    ZASSERT (1); 
}


void       zplfCompMac_I_Gen   (zCOMPLEX   *pfSrcDest, zCOMPLEX    *pfSrc1, float   *pfSrc2, int   iRealLengthAsPowOf4)
{
    int    i,
            iDoubleNumOfSamples = (iRealLengthAsPowOf4<<1);

    ZASSERT (pfSrc1 == 0 || pfSrc2 == 0 || pfSrcDest == 0);
    ZASSERT ((iRealLengthAsPowOf4 < 0) || (iRealLengthAsPowOf4%4 != 0));

    pfSrcDest[0]                    += pfSrc1[0] * pfSrc2[0];
    pfSrcDest[iRealLengthAsPowOf4]  += pfSrc1[iRealLengthAsPowOf4] * pfSrc2[iRealLengthAsPowOf4];

    //Re
    for (i = 1; i < iRealLengthAsPowOf4; i++)
        pfSrcDest[i] += pfSrc1[i] * pfSrc2[i] - pfSrc1[iDoubleNumOfSamples-i] * pfSrc2[iDoubleNumOfSamples-i];
    //Im
    for (i = iRealLengthAsPowOf4+1; i < iDoubleNumOfSamples; i++)
        pfSrcDest[i] += pfSrc1[i] * pfSrc2[iDoubleNumOfSamples-i] + pfSrc1[iDoubleNumOfSamples-i] * pfSrc2[i];

    return;
}


void       zplfCompAbs_Gen     (float   *pfDest,    zCOMPLEX    *pfSrc1, int iRealLengthAsPowOf4)
{
    int    i;

    float  *pfImagData = pfSrc1 + iRealLengthAsPowOf4;

    ZASSERT (pfSrc1 == 0 || pfDest == 0);
    ZASSERT ((iRealLengthAsPowOf4 < 0) || (iRealLengthAsPowOf4%4 != 0));

    pfDest[0] = ZABS (pfSrc1[0]);
        
    for (i = 1; i < iRealLengthAsPowOf4; i++)
        pfDest[i]       = sqrtf (pfSrc1[i] * pfSrc1[i] + pfImagData[iRealLengthAsPowOf4-i] * pfImagData[iRealLengthAsPowOf4-i]);

    return;
}


int zplfZeroCrossings_Gen (float *pfSrc, int iLengthAsPowOf4)
{
    ZASSERT (pfSrc == 0);
    ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));

    int iResult = 0;
    for (int i = 1; i < iLengthAsPowOf4; i++)
    {
        if (pfSrc[i] * pfSrc[i-1] < 0)
            iResult++;
    }
    return iResult;
}

---