vInit.h

 
//  Векторно-матричная библиотека
//
//  Copyright (c) RC Module Inc.
//
//  $Revision: 1.1 $      $Date: 2004/11/22 13:50:02 $
//
//------------------------------------------------------------------------
#ifndef _VINIT_H_INCLUDED_
#define _VINIT_H_INCLUDED_
 
 
#ifdef __cplusplus
        extern "C" {
#endif
 
 
void nmppsSet_8s  (  int8b  val, nm8s*   pDst, int len);
void nmppsSet_16s ( int16b  val, nm16s*  pDst, int len);
void nmppsSet_32s ( int32b  val, nm32s*  pDst, int len);
void nmppsSet_64s ( int64b  val, nm64s*  pDst, int len);
void nmppsSet_64sc(int64sc  val, nm64sc* pDst, int len);
//void nmppsSet_64sp( int64b* pVal,nm64s* pDst, int len);
//__INLINE__ void nmppsSet_64s(nm64s* pDst, int64b  val, int len)  {nmppsSet_64sp((nm64s*) pDst, (int64b*)&val, len);}
 
__INLINE__ void nmppsSet_8u ( uint8b val, nm8u*  pDst, int len) {nmppsSet_8s ( (int8b)val,  (nm8s*) pDst, len);}
__INLINE__ void nmppsSet_16u(uint16b val, nm16u* pDst, int len) {nmppsSet_16s((int16b)val, (nm16s*) pDst, len);}
__INLINE__ void nmppsSet_32u(uint32b val, nm32u* pDst, int len) {nmppsSet_32s((int32b)val, (nm32s*) pDst, len);}
__INLINE__ void nmppsSet_64u(uint64b val, nm64u* pDst, int len) {nmppsSet_64s((int64b)val, (nm64s*) pDst, len);}
 
//__INLINE__ void nmppsSet_16sc (nm16sc val, nm16sc* pDst, int len);
//__INLINE__ void nmppsSet_32sc (nm32sc val, nm32sc* pDst, int len);
 
 
//__INLINE__ void nmppsSet_64up(nm64u* pDst, uint64b* val, int len){nmppsSet_64sp((nm64s*) pDst, (int64b*)val, len);}
 
 
 
 
//*****************************************************************************
 
 
//void nmppsRandUniform_32u(nm32u* pDstVec, int nSize, unsigned nRandomize );
void nmppsRandUniform_64s(nm64s* pDstVec, int nSize);
__INLINE__ void nmppsRandUniform_8s (nm8s* pDstVec,  int nSize) {nmppsRandUniform_64s((nm64s*)pDstVec,  nSize>>3);}
__INLINE__ void nmppsRandUniform_16s(nm16s* pDstVec, int nSize) {nmppsRandUniform_64s((nm64s*)pDstVec,  nSize>>2);}
__INLINE__ void nmppsRandUniform_32s(nm32s* pDstVec, int nSize) {nmppsRandUniform_64s((nm64s*)pDstVec,  nSize>>1);}
__INLINE__ void nmppsRandUniform_8u (nm8u* pDstVec,  int nSize) {nmppsRandUniform_64s((nm64s*)pDstVec,  nSize>>3);}
__INLINE__ void nmppsRandUniform_16u(nm16u* pDstVec, int nSize) {nmppsRandUniform_64s((nm64s*)pDstVec,  nSize>>2);}
__INLINE__ void nmppsRandUniform_32u(nm32u* pDstVec, int nSize) {nmppsRandUniform_64s((nm64s*)pDstVec,  nSize>>1);}
__INLINE__ void nmppsRandUniform_64u(nm64u* pDstVec, int nSize) {nmppsRandUniform_64s((nm64s*)pDstVec,  nSize   );}
 
//__INLINE__ void nmppsRandUniform_64s(nm64s* pDstVec, int nSize, unsigned nRandomize = 1) {nmppsRandUniform_32u((nm32u*)pDstVec,  nSize<<1, nRandomize);}
 
 
 
    //*****************************************************************************
 
void nmppsRandUniform_64f(nm64f* pDstVec, int nSize, double low, double hi);
void nmppsRand_32f(nm32f* pDstVec, int nSize,float low,float hi);
 
void nmppsRandUniform_32f_integer(nm32f *pDstVec,int nSize,int hi,int low);
 
    
 
//*****************************************************************************
 
int nmppsRandUniform2_32s(int nMin, int nMax, int nDivisible);
int nmppsRandUniform3_32s(int nMin, int nMax);
int nmppsRandUniform();
 
 
 
//*****************************************************************************
 
void nmppsRamp_8s(nm8s* pVec,  int8b nOffset,  int8b nSlope, int nSize);
void nmppsRamp_16s(nm16s* pVec, int16b nOffset, int16b nSlope, int nSize);
void nmppsRamp_32s(nm32s* pVec, int32b nOffset, int32b nSlope, int nSize);
void nmppsRamp_64s(nm64s* pVec, int64b nOffset, int64b nSlope, int nSize);
 
//*****************************************************************************
 
    //todo Impelenment NM versin of void nmppsConvert_32s(nm32s *pSrcVec, nm4s *pDstVec, int nSize);
 
void nmppsConvert_1s2s  (const nm1* pSrcVec, nm2s* pDstVec, int nSize);
void nmppsConvert_1u2u  (const nm1* pSrcVec, nm2u* pDstVec, int nSize);
void nmppsConvert_1u4u  (const nm1* pSrcVec, nm4u* pDstVec, int nSize);
 
void nmppsConvert_2s1s  (const nm2s* pSrcVec, nm1*  pDstVec, int nSize);
void nmppsConvert_2s4s  (const nm2s* pSrcVec, nm4s* pDstVec, int nSize);
void nmppsConvert_2u4u  (const nm2u* pSrcVec, nm4u* pDstVec, int nSize);
 
void nmppsConvert_4s1s  (const nm4s* pSrcVec, nm1*  pDstVec, int nSize);
void nmppsConvert_4s2s  (const nm4s* pSrcVec, nm2s* pDstVec, int nSize);
void nmppsConvert_4s8s  (const nm4s* pSrcVec, nm8s* pDstVec, int nSize);
void nmppsConvert_4u8u  (const nm4u* pSrcVec, nm8u* pDstVec, int nSize);
 
void nmppsConvert_8s4s  (const nm8s* pSrcVec, nm4s*  pDstVec, int nSize);
void nmppsConvert_8s16s (const nm8s* pSrcVec, nm16s* pDstVec, int nSize);
void nmppsConvert_8s32s (const nm8s* pSrcVec, nm32s* pDstVec, int nSize);
void nmppsConvert_8s64s (const nm8s* pSrcVec, nm64s* pDstVec, int nSize);
void nmppsConvert_8u16u (const nm8u* pSrcVec, nm16u* pDstVec, int nSize);
void nmppsConvert_8u32u (const nm8u* pSrcVec, nm32u* pDstVec, int nSize);
void nmppsConvert_8u64u (const nm8u* pSrcVec, nm64u* pDstVec, int nSize);
 
void nmppsConvert_16s4s (const nm16s* pSrcVec, nm4s* pDstVec, int nSize);
void nmppsConvert_16s8s (const nm16s* pSrcVec, nm8s* pDstVec, int nSize);
void nmppsConvert_16s32s(const nm16s* pSrcVec, nm32s* pDstVec, int nSize);
void nmppsConvert_16s64s(const nm16s* pSrcVec, nm64s* pDstVec, int nSize);
void nmppsConvert_16u32u(const nm16u* pSrcVec, nm32u* pDstVec, int nSize);
void nmppsConvert_16u64u(const nm16u* pSrcVec, nm64u* pDstVec, int nSize);
 
void nmppsConvert_32s8s (const nm32s* pSrcVec, nm8s* pDstVec, int nSize);
void nmppsConvert_32s16s(const nm32s* pSrcVec, nm16s* pDstVec, int nSize);
void nmppsConvert_32s64s(const nm32s* pSrcVec, nm64s* pDstVec, int nSize);
void nmppsConvert_32u64u(const nm32u* pSrcVec, nm64u* pDstVec, int nSize);
 
void nmppsConvert_64s32s(const nm64s* pSrcVec, nm32s* pDstVec, int nSize);
void nmppsConvert_64s16s(const nm64s* pSrcVec, nm16s* pDstVec, int nSize);
 
//void nmppsConvert_32s(nm32s *pSrcVec, nm4s *pDstVec, int nSize);
 
 
//*****************************************************************************
 
void nmppsConvert_32u32fcr(const nm32u* pSrcVec, nm32fcr* pDstVec, int nSize);
void nmppsConvert_32s32fcr(const nm32s* pSrcVec, nm32fcr* pDstVec, int nSize);
void nmppsConvert_32f32fcr(const nm32f* pSrcVec, nm32fcr* pDstVec, int nSize);
void nmppsConvert_32sc32fcr(const nm32sc* pSrcVec, nm32fcr* pDstVec, int nSize);
void nmppsConvert_32s32f(const nm32s* pSrcVec, nm32f* pDstVec, int nSize);
void nmppsConvert_32f64f(const nm32f* pSrcVec, nm64f* pDstVec, int nSize);
void nmppsConvert_64f32f(const nm64f* pSrcVec, nm32f* pDstVec, int nSize);
 
void nmppsConvert_32f32s_rounding(const nm32f* pSrcVec, nm32s* pDstVec, int scale, int nSize);
void nmppsConvert_32f32f_ceiling (const nm32f* pSrcVec, nm32f* pDstVec, int scale, int nSize);
void nmppsConvert_32f32s_ceiling (const nm32f* pSrcVec, nm32s* pDstVec, int scale, int nSize);
void nmppsConvert_32f32s_floor   (const nm32f* pSrcVec, nm32s* pDstVec, int scale, int nSize);
void nmppsConvert_32f32s_truncate(const nm32f* pSrcVec, nm32s* pDstVec, int scale, int nSize);
 
void nmppsMerge_32f(const nm32f* pSrcVec1, const nm32f* pSrcVec2, nm32f* pDstVec, int nSize);
 
void nmppsConvertRisc_8u32u(const nm8u* pSrcVec, nm32u* pDstVec, int nSize);
void nmppsConvertRisc_32u8u(const nm32u* pSrcVec, nm8u* pDstVec, int nSize);
 
//*****************************************************************************
 
 
void nmppsCopy_2s (const nm2s*  pSrcVec, nm2s*  pDstVec, int nSize);
void nmppsCopy_4s (const nm4s*  pSrcVec, nm4s*  pDstVec, int nSize);
void nmppsCopy_8s (const nm8s*  pSrcVec, nm8s*  pDstVec, int nSize);
void nmppsCopy_16s(const nm16s* pSrcVec, nm16s* pDstVec, int nSize);
void nmppsCopy_32s(const nm32s* pSrcVec, nm32s* pDstVec, int nSize);
void nmppsCopy_64s(const nm64s* pSrcVec, nm64s* pDstVec, int nSize);
 
__INLINE__ void nmppsCopy_4u (const nm4u*  pSrcVec, nm4u*  pDstVec, int nSize) { nmppsCopy_4s (( nm4s*)  pSrcVec, (nm4s*)  pDstVec,  nSize);}
__INLINE__ void nmppsCopy_8u (const nm8u*  pSrcVec, nm8u*  pDstVec, int nSize) { nmppsCopy_8s (( nm8s*)  pSrcVec, (nm8s*)  pDstVec,  nSize);}
__INLINE__ void nmppsCopy_16u(const nm16u* pSrcVec, nm16u* pDstVec, int nSize) { nmppsCopy_16s(( nm16s*) pSrcVec, (nm16s*) pDstVec,  nSize);}
__INLINE__ void nmppsCopy_32u(const nm32u* pSrcVec, nm32u* pDstVec, int nSize) { nmppsCopy_32s(( nm32s*) pSrcVec, (nm32s*) pDstVec,  nSize);}
__INLINE__ void nmppsCopy_64u(const nm64u* pSrcVec, nm64u* pDstVec, int nSize) { nmppsCopy_64s(( nm64s*) pSrcVec, (nm64s*) pDstVec,  nSize);}
__INLINE__ void nmppsCopy_64sc(const nm64sc *pSrcVec, nm64sc *pDstVec, int nSize) { nmppsCopy_64s(( nm64s*) pSrcVec, (nm64s*) pDstVec,  2*nSize);}
 
 
void nmppsCopy_32f(const float* pSrcVec, float* pDstVec, int size);
 
void nmppsCopyOddToOdd_32f(const float* pSrcVec, float* pDstVec, int size);
 
void nmppsCopyEvenToOdd_32f(const float* pSrcVec, float* pDstVec, int size);
 
 
void nmppsCopyOddToEven_32f(const float* pSrcVec, float* pDstVec, int size);
 
 
void nmppsCopyEvenToEven_32f(const float* pSrcVec, float* pDstVec, int size);
 
 
void nmppsCopyRisc_32f(const float* pSrcVec, float* pDstVec, int nSize);
 
//*****************************************************************************
 
void nmppsCopyua_8s(const nm8s* pSrcVec, int nSrcOffset, nm8s* pDstVec,  int nSize);
 
//*****************************************************************************
 
void nmppsSwap_64s(nm64s* pSrcVec1, nm64s* pSrcVec2, int nSize);
 
 
 
 
#ifdef __cplusplus
        };
#endif
 
#endif // _INIT_H_INCLUDED_