ipps.hpp

经典的嵌入式教程C和C++的内容中的源代码

 inline IppStatus ippsSet( Ipp32s val, Ipp32s* pDst, int len) {
     return ippsSet_32s( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp32sc val, Ipp32sc* pDst, int len) {
     return ippsSet_32sc( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp32f val, Ipp32f* pDst, int len) {
     return ippsSet_32f( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp32fc val, Ipp32fc* pDst, int len) {
     return ippsSet_32fc( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp64s val, Ipp64s* pDst, int len) {
     return ippsSet_64s( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp64sc val, Ipp64sc* pDst, int len) {
     return ippsSet_64sc( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp64f val, Ipp64f* pDst, int len) {
     return ippsSet_64f( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp64fc val, Ipp64fc* pDst, int len) {
     return ippsSet_64fc( val, pDst, len );
     }

/* ////////////////////////////////////////////////////////////////////////////
//  Name:       ippsRandUniform_Direct_16s, ippsRandUniform_Direct_32f, ippsRandUniform_Direct_64f
//
//  Purpose:    Makes pseudo-random samples with a uniform distribution and places them in
//              the vector.
//
//
//  Return:
//    ippStsNoErr              Ok
//    ippStsNullPtrErr         The pointer to vector is NULL
//    ippStsBadSizeErr         The length of the vector is less or equal zero
//
//  Arguments:
//    low                      The lower bounds of the uniform distributions range.
//    high                     The upper bounds of the uniform distributions range.
//    pSeed                    The pointer to the seed value used by the pseudo-random number
//                             generation algorithm.
//    pSrcDst                  The pointer to vector
//    len                      Vector's length
*/

 inline IppStatus ippsRandUniform_Direct( Ipp16s* pDst, int len, Ipp16s low, Ipp16s
                             high, unsigned int* pSeed) {
     return ippsRandUniform_Direct_16s( pDst, len, low, high, pSeed );
     }
 inline IppStatus ippsRandUniform_Direct( Ipp32f* pDst, int len, Ipp32f low, Ipp32f
                             high, unsigned int* pSeed) {
     return ippsRandUniform_Direct_32f( pDst, len, low, high, pSeed );
     }
 inline IppStatus ippsRandUniform_Direct( Ipp64f* pDst, int len, Ipp64f low, Ipp64f
                             high, unsigned int* pSeed) {
     return ippsRandUniform_Direct_64f( pDst, len, low, high, pSeed );
     }

/* ////////////////////////////////////////////////////////////////////////////
//  Name:       ippsRandGauss_Direct_16s, ippsRandGauss_Direct_32f, ippsRandGauss_Direct_64f
//
//  Purpose:    Makes pseudo-random samples with a Normal distribution distribution and places
//              them in the vector.
//
//
//  Return:
//    ippStsNoErr              Ok
//    ippStsNullPtrErr         The pointer to vector is NULL
//    ippStsBadSizeErr         The length of the vector is less or equal zero
//
//  Arguments:
//    mean                     The mean of the Normal distribution.
//    stdev                    The standard deviation of the Normal distribution.
//    pSeed                    The pointer to the seed value used by the pseudo-random number
//                             generation algorithm.
//    pSrcDst                  The pointer to vector
//    len                      Vector's length
*/

 inline IppStatus ippsRandGauss_Direct( Ipp16s* pDst, int len, Ipp16s mean, Ipp16s
                             stdev, unsigned int* pSeed) {
     return ippsRandGauss_Direct_16s( pDst, len, mean, stdev, pSeed );
     }
 inline IppStatus ippsRandGauss_Direct( Ipp32f* pDst, int len, Ipp32f mean, Ipp32f
                             stdev, unsigned int* pSeed) {
     return ippsRandGauss_Direct_32f( pDst, len, mean, stdev, pSeed );
     }
 inline IppStatus ippsRandGauss_Direct( Ipp64f* pDst, int len, Ipp64f mean, Ipp64f
                             stdev, unsigned int* pSeed) {
     return ippsRandGauss_Direct_64f( pDst, len, mean, stdev, pSeed );
     }

/* ///////////////////////////////////////////////////////////////////////// */
//-- #if !defined( _OWN_BLDPCS )

//-- struct RandUniState_8u;
//-- struct RandUniState_16s;
//-- struct RandUniState_32f;

//-- typedef struct RandUniState_8u IppsRandUniState_8u;
//-- typedef struct RandUniState_16s IppsRandUniState_16s;
//-- typedef struct RandUniState_32f IppsRandUniState_32f;

//-- struct RandGaussState_8u;
//-- struct RandGaussState_16s;
//-- struct RandGaussState_32f;

//-- typedef struct RandGaussState_8u IppsRandGaussState_8u;
//-- typedef struct RandGaussState_16s IppsRandGaussState_16s;
//-- typedef struct RandGaussState_32f IppsRandGaussState_32f;

//-- #endif

/* /////////////////////////////////////////////////////////////////////////
// Name:                ippsRandUniformInitAlloc_8u,  ippsRandUniformInitAlloc_16s,
//                      ippsRandUniformInitAlloc_32f
// Purpose:             Allocate and initializate parameters for the generator
//                      of noise with uniform distribution.
// Returns:
// Parameters:
//    pRandUniState     A pointer to the structure containing parameters for the
//                      generator of noise.
//    low               The lower bounds of the uniform distribution's range.
//    high              The upper bounds of the uniform distribution's range.
//    seed              The seed value used by the pseudo-random number generation
//                      algorithm.
//
// Returns:
//    ippStsNullPtrErr  pRandUniState==NULL
//    ippMemAllocErr    Can not allocate random uniform state
//    ippStsNoErr       No errors
//
*/
 inline IppStatus ippsRandUniformInitAlloc( IppsRandUniState_8u** pRandUniState, Ipp8u
                             low, Ipp8u high, unsigned int seed) {
     return ippsRandUniformInitAlloc_8u( pRandUniState, low, high, seed );
     }

 inline IppStatus ippsRandUniformInitAlloc( IppsRandUniState_16s** pRandUniState,
                             Ipp16s low, Ipp16s high, unsigned int seed) {
     return ippsRandUniformInitAlloc_16s( pRandUniState, low, high, seed );
     }

 inline IppStatus ippsRandUniformInitAlloc( IppsRandUniState_32f** pRandUniState,
                             Ipp32f low, Ipp32f high, unsigned int seed) {
     return ippsRandUniformInitAlloc_32f( pRandUniState, low, high, seed );
     }

/* /////////////////////////////////////////////////////////////////////////
// Name:                     ippsRandUniform_8u,  ippsRandUniform_16s,
//                           ippsRandUniform_32f
// Purpose:                  Makes pseudo-random samples with a uniform distribution
//                           and places them in the vector.
// Parameters:
//    pDst                   The pointer to vector
//    len                    Vector's length
//    pRandUniState          A pointer to the structure containing parameters for the
//                           generator of noise
// Returns:
//    ippStsNullPtrErr       pRandUniState==NULL
//    ippStsContextMatchErr  pState->idCtx != idCtxRandUni
//    ippStsNoErr            No errors
*/

 inline IppStatus ippsRandUniform( Ipp8u* pDst, int len, IppsRandUniState_8u*
                             pRandUniState) {
     return ippsRandUniform_8u( pDst, len, pRandUniState );
     }
 inline IppStatus ippsRandUniform( Ipp16s* pDst, int len, IppsRandUniState_16s*
                             pRandUniState) {
     return ippsRandUniform_16s( pDst, len, pRandUniState );
     }
 inline IppStatus ippsRandUniform( Ipp32f* pDst, int len, IppsRandUniState_32f*
                             pRandUniState) {
     return ippsRandUniform_32f( pDst, len, pRandUniState );
     }

/* /////////////////////////////////////////////////////////////////////////
// Name:                     ippsRandUniformFree_8u, ippsRandUniformFree_16s
//                           ippsRandUniformFree_32f
// Purpose:                  Close random uniform state
//
// Parameters:
//    pRandUniState          Pointer to the random uniform state
//
// Returns:
//    ippStsNullPtrErr       pState==NULL
//    ippStsContextMatchErr  pState->idCtx != idCtxRandUni
//    ippStsNoErr,           No errors
*/

 inline IppStatus ippsRandUniformFree( IppsRandUniState_8u* pRandUniState) {
     return ippsRandUniformFree_8u( pRandUniState );
     }
 inline IppStatus ippsRandUniformFree( IppsRandUniState_16s* pRandUniState) {
     return ippsRandUniformFree_16s( pRandUniState );
     }
 inline IppStatus ippsRandUniformFree( IppsRandUniState_32f* pRandUniState) {
     return ippsRandUniformFree_32f( pRandUniState );
     }


/* //////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////
// Name:                ippsRandGaussInitAlloc_8u,  ippsRandGaussInitAlloc_16s,
//                      ippsRandGaussInitAlloc_32f
// Purpose:             Allocate and initializate parameters for the generator of noise.
// Returns:
// Parameters:
//    pRandGaussState   A pointer to the structure containing parameters for the
//                      generator of noise.
//    mean              The mean of the normal distribution.
//    stdDev            The standard deviation of the normal distribution.
//    seed              The seed value used by the pseudo-random number
//
// Returns:
//    ippStsNullPtrErr  pRandGaussState==NULL
//    ippMemAllocErr    Can not allocate normal random state
//    ippStsNoErr       No errors
//
*/
 inline IppStatus ippsRandGaussInitAlloc( IppsRandGaussState_8u** pRandGaussState,
                             Ipp8u mean, Ipp8u stdDev, unsigned int seed) {
     return ippsRandGaussInitAlloc_8u( pRandGaussState, mean, stdDev, seed );
     }

 inline IppStatus ippsRandGaussInitAlloc( IppsRandGaussState_16s** pRandGaussState,
                             Ipp16s mean, Ipp16s stdDev, unsigned int seed) {
     return ippsRandGaussInitAlloc_16s( pRandGaussState, mean, stdDev, seed );
     }

 inline IppStatus ippsRandGaussInitAlloc( IppsRandGaussState_32f** pRandGaussState,
                             Ipp32f mean, Ipp32f stdDev, unsigned int seed) {
     return ippsRandGaussInitAlloc_32f( pRandGaussState, mean, stdDev, seed );
     }

/* /////////////////////////////////////////////////////////////////////////
// Name:                     ippsRandGauss_8u,  ippsRandGauss_16s,
//                           ippsRandGauss_32f
// Purpose:                  Makes pseudo-random samples with a normal distribution
//                           and places them in the vector.
// Parameters:
//    pDst                   The pointer to vector
//    len                    Vector's length
//    pRandUniState          A pointer to the structure containing parameters
//                           for the generator of noise
//    ippStsContextMatchErr  pState->idCtx != idCtxRandGauss
// Returns:
//    ippStsNullPtrErr       pRandGaussState==NULL
//    ippStsNoErr            No errors
*/

 inline IppStatus ippsRandGauss( Ipp8u* pDst, int len, IppsRandGaussState_8u*
                             pRandGaussState) {
     return ippsRandGauss_8u( pDst, len, pRandGaussState );
     }
 inline IppStatus ippsRandGauss( Ipp16s* pDst, int len, IppsRandGaussState_16s*
                             pRandGaussState) {
     return ippsRandGauss_16s( pDst, len, pRandGaussState );
     }
 inline IppStatus ippsRandGauss( Ipp32f* pDst, int len, IppsRandGaussState_32f*
                             pRandGaussState) {
     return ippsRandGauss_32f( pDst, len, pRandGaussState );
     }

/* /////////////////////////////////////////////////////////////////////////
// Name:                     ippsRandGaussFree_8u, ippsRandGaussFree_16s,
//                           ippsRandGaussFree_32f
// Purpose:                  Close random normal state
//
// Parameters:
//    pRandUniState          Pointer to the random normal state
//
// Returns:
//    ippStsNullPtrErr       pState==NULL
//    ippStsContextMatchErr  pState->idCtx != idCtxRandGauss
//    ippStsNoErr,           No errors
*/

 inline IppStatus ippsRandGaussFree( IppsRandGaussState_8u* pRandGaussState) {
     return ippsRandGaussFree_8u( pRandGaussState );
     }
 inline IppStatus ippsRandGaussFree( IppsRandGaussState_16s* pRandGaussState) {
     return ippsRandGaussFree_16s( pRandGaussState );
     }
 inline IppStatus ippsRandGaussFree( IppsRandGaussState_32f* pRandGaussState) {
     return ippsRandGaussFree_32f( pRandGaussState );
     }

/* ////////////////////////////////////////////////////////////////////////////
//  Name:       ippsRandGaussGetSize_16s
//
//  Purpose:    Gaussian sequence generator state variable size -
//              computes the size,in bytes,
//              of the state variable structure ippsRandGaussState_16s.
//  Return:
//    ippStsNoErr              Ok
//    ippStsNullPtrErr         pRandGaussStateSize==NULL
//  Arguments: