nmtype.h

См. документацию.

 
 
//------------------------------------------------------------------------
//
//  $Workfile:: nmtype.h              $
//
//  Векторно-матричная библиотека
//
//  Copyright (c) RC Module Inc.
//
//  $Revision: 1.1 $      $Date: 2004/11/22 13:50:02 $
//
//------------------------------------------------------------------------
 
 
#ifndef _NMTYPE_H_INCLUDED2_
#define _NMTYPE_H_INCLUDED2_
 
#define MEM_LOCAL  0
#define MEM_GLOBAL 1
#define HEAP0 0
#define HEAP1 1
#define HEAP2 2
#define HEAP3 3
 
#ifdef __GNUC__
#define __int64 long long
#endif
// if new compiler
#ifdef __NM__
    //typedef long __int64;
#endif
    typedef signed long long  INT64;
    typedef unsigned long long UINT64;
 
#ifdef __NM__
#define sizeof32(t) sizeof(t)
//#define malloc32(size_int32) malloc(size_int32)
#else
#define sizeof32(t) (sizeof(t)/4)
//#define malloc32(size_int32) malloc(size_int32*4)
#endif
 
 
 
//-----------------------------------------------------------------------------
struct nmreg { int nVal; };
//-----------------------------------------------------------------------------
 
//*****************************************************************************
 
//-----------------------------------------------------------------------------
    #ifdef __NM__
typedef void nm1;
#else
    typedef int nm1;
#endif
//-----------------------------------------------------------------------------
typedef void nm2s;
//-----------------------------------------------------------------------------
typedef void nm4s;
//-----------------------------------------------------------------------------
    /*
struct int8x8{
#ifdef __NM__
    unsigned long items;
#else
    signed char item[8];
#endif
};*/
 
//#ifdef __NM__
//  typedef void nm8s;
//#else
//  typedef signed char nm8s;
//#endif
 
#ifdef __NM__
#ifdef __cplusplus
    typedef struct {
        virtual void func() = 0;
    } nm8s;
#else
    typedef void nm8s;
#endif
 
#else
    typedef char nm8s;
#endif
 
    
 
//typedef signed char nm8s;
//typedef void nm8s;
//typedef struct s_nm8s{
//#ifdef __NM__
//  unsigned long vec;
//#else
//  char num[8];
//#endif
//} nm8s;
//
 
 
//-----------------------------------------------------------------------------
//typedef signed char nm8s7b;
    typedef nm8s nm8s7b;
/*struct int7in8x8{
#ifdef __NM__
    unsigned long items;
#else
    char item[8];
#endif
};*/
//-----------------------------------------------------------------------------
/*
struct int16x4{
#ifdef __NM__
    unsigned long items;
#else
    signed short item[4];
#endif
};
*/
 
//#ifdef __NM__
//typedef void nm16s;
//#else
//typedef signed short nm16s;
//#endif
 
#ifdef __NM__
#ifdef __cplusplus
typedef struct {
    virtual void func() = 0;
} nm16s;
#else
typedef void nm16s;
#endif
 
#else
typedef short nm16s;
#endif
 
 
 
 
 
//-----------------------------------------------------------------------------
typedef nm16s nm16s15b;
 
 
 
struct int15in16x4{
#ifdef __NM__
    unsigned long items;
#else
    signed short item[4];
#endif
};
 
 
 
 
//-----------------------------------------------------------------------------
typedef int nm32s;
typedef struct s_int32x2{
//public:
    int hi;
    int lo;
    //unsigned long long data;
//  int32x2(){
//      data=0;
//  }
//  int32x2(int item0, int item1){
//      set(0,item0);
//      set(1,item1);
//  }
//  int32x2& operator = (unsigned long long value){
//      data = value;
//      return *this;
//  }
//  int &lo(){
//      return *((int*)&data);
//  }
//  int &hi(){
//      return *(((int*)&data)+1);
//  }
//  void set(int indx, int value){
//      ((int*)&data)[indx]=value;
//  }
//  int get(int indx){
//      return ((int*)&data)[indx];
//  }
}int32x2;
//-----------------------------------------------------------------------------
typedef int nm32s31b;
struct int31in32x2{
#ifdef __NM__
    unsigned long items;
#else
    int item[2];
#endif
};
//-----------------------------------------------------------------------------
typedef int nm32s30b;
struct int30in32x2{
#ifdef __NM__
    unsigned long items;
#else
    int item[2];
#endif
};
//-----------------------------------------------------------------------------
//typedef __int64 nm64s;
typedef long long nm64s;
 
 
//-----------------------------------------------------------------------------
typedef nm64s nm64s63b;
//=============================================================================
typedef void nm2u;
//-----------------------------------------------------------------------------
typedef void nm4u;
typedef nm4u nm4u3b;
 
//-----------------------------------------------------------------------------
 
#ifdef __NM__
    typedef void nm8u;
#else
    typedef unsigned char nm8u;
#endif
//-----------------------------------------------------------------------------
 
typedef  nm8u nm8u7b;
//-----------------------------------------------------------------------------
#ifdef __NM__
    typedef void nm16u;
#else
    typedef unsigned short nm16u;
#endif
//-----------------------------------------------------------------------------
typedef nm16u nm16u15b;
//-----------------------------------------------------------------------------
typedef unsigned int nm32u;
 
//-----------------------------------------------------------------------------
typedef unsigned int nm32u31b;
//-----------------------------------------------------------------------------
typedef unsigned long long nm64u;
//=============================================================================
 
 
 
//=============================================================================
typedef int int1b;
//-----------------------------------------------------------------------------
typedef int int2b;
//-----------------------------------------------------------------------------
typedef int int3b;
//-----------------------------------------------------------------------------
typedef int int4b;
//-----------------------------------------------------------------------------
typedef int int7b;
//-----------------------------------------------------------------------------
typedef int int8b;
//-----------------------------------------------------------------------------
typedef int int15b;
//-----------------------------------------------------------------------------
typedef int int16b;
//-----------------------------------------------------------------------------
typedef int int30b;
//-----------------------------------------------------------------------------
typedef int int31b;
//-----------------------------------------------------------------------------
typedef int int32b;
//-----------------------------------------------------------------------------
typedef INT64 int63b;
//-----------------------------------------------------------------------------
typedef INT64 int64b;
//=============================================================================
typedef unsigned int uint1b;
//-----------------------------------------------------------------------------
typedef unsigned int uint2b;
//-----------------------------------------------------------------------------
typedef unsigned int uint3b;
//-----------------------------------------------------------------------------
typedef unsigned int uint4b;
//-----------------------------------------------------------------------------
typedef unsigned int uint7b;
//-----------------------------------------------------------------------------
typedef unsigned int uint8b;
//-----------------------------------------------------------------------------
typedef unsigned int uint15b;
//-----------------------------------------------------------------------------
typedef unsigned int uint16b;
//-----------------------------------------------------------------------------
typedef unsigned int uint31b;
//-----------------------------------------------------------------------------
typedef unsigned int uint32b;
//-----------------------------------------------------------------------------
typedef UINT64 uint63b;
//-----------------------------------------------------------------------------
typedef nm64u uint64b;
 
 
 
 
//=============================================================================
 
//================= nmget ===========================================
/*
int2b   nmget_2s(struct nm2s*  pVec, int nIndex)
{
    nm32u nBase=((nm32u)nIndex)/16;
    nm32u nDisp=((nm32u)nIndex)%16;
    nm32s nVal=((nm32s*)pVec)[nBase];
    nDisp<<=1;
    nVal<<=(32-2-nDisp);
    nVal>>=30;
    return nVal;
}
 
__INLINE__ int4b nmget_4s(nm4s*  pVec, int nIndex)
{
    nm32u nBase=((nm32u)nIndex)/8;
    nm32u nDisp=((nm32u)nIndex)%8;
    nm32s nVal=((nm32s*)pVec)[nBase];
    nDisp<<=2;
    nVal<<=(32-4-nDisp);
    nVal>>=28;
    return nVal;
}
 
__INLINE__ int8b    nmget_8s(nm8s*  pVec, int nIndex)
{
    return (char*)pVec[nIndex];
}
 
__INLINE__ int16b   nmget_16s(nm16s* pVec, int nIndex)
{
    return (hsort)pVec[nIndex];
}
 
---------------- uint ------------------------------------
__INLINE__ uint1b nmget_1u(nm1*   pVec, int nIndex)
{
    nm32u nBase=((nm32u)nIndex)/32;
    nm32u nDisp=((nm32u)nIndex)%32;
    nm32u nVal=((nm32u*)pVec)[nBase];
    nVal>>=nDisp;
    nVal&=1;
    return nVal;
}
__INLINE__ uint2b   nmget_2u(nm2u*  pVec, int nIndex)
{
    nm32u nBase=((nm32u)nIndex)/16;
    nm32u nDisp=((nm32u)nIndex)%16;
    nm32u nVal=((nm32u*)pVec)[nBase];
    nVal>>=nDisp*2;
    nVal&=3;
    return nVal;
}
 
 
__INLINE__ uint4b   nmget_4u(nm4u*  pVec, int nIndex)
{
    nm32u nBase=((nm32u)nIndex)/8;
    nm32u nDisp=((nm32u)nIndex)%8;
    nm32u nVal=((nm32u*)pVec)[nBase];
    nVal>>=nDisp*4;
    nVal&=15;
    return nVal;
}
 
__INLINE__ uint8b   nmget_8u(nm8u*  pVec, int nIndex)
{
    return pVec[nIndex];
}
 
__INLINE__ uint16b  nmget_16u(nm16u* pVec, int nIndex)
{
    return pVec[nIndex];
}
*/
 
//=============================================================================
#define VEC_NM1(X)  unsigned data[(X)/32];
#define VEC_NM2U(X) unsigned data[(X)/16];
#define VEC_NM2S(X) int data[(X)/16];
#define VEC_NM4U(X) \
    unsigned data[(X)/8]; \
    uint4b get(int nIndex){return nmget((nm4u*)data,nIndex); }\
    uint4b operator[] (int index){ return nmget((nm4u*)data,index);}
 
 
#define VEC_NM4S(X) int data[(X)/8];
#define VEC_NM8U(X) unsigned int data[(X)/4];
#define VEC_NM8S(X) \
    int data[(X)/4]; \
    void set(int i, int val){ ((char*)data)[i]=val;}        \
    char operator[] (int index){ return ((char*)data)[index];}
 
#define VEC_NM16U(X) \
    unsigned int data[(X)/2]; \
    void set(int i, int val){ ((unsigned short*)data)[i]=val;}      \
    unsigned short operator[] (int index){ return ((unsigned short*)data)[index];}
 
#define VEC_NM16S(X) \
    int data[(X)/2]; \
    void set(int i, int val){ ((unsigned short*)data)[i]=val;}      \
    short operator[] (int index){ return ((unsigned short*)data)[index];}
 
#define VEC_NM32U(X) nm32u data[(X)];
#define VEC_NM32S(X) \
    int data[(X)];  \
    void set(int i, int val){ ((int*)data)[i]=val;}     \
    int operator[] (int index){ return ((int*)data)[index];}
 
 
 
 
//-----------------------------------------------------------------------------
//struct v16nm4s {VEC_NM4S(16)};
struct v16nm4s {
    unsigned long long vec[1];
};
 
//-----------------------------------------------------------------------------
//struct v4{VEC_NM8S(4)};
struct v4nm8s {
    unsigned long long vec[1];
};
//-----------------------------------------------------------------------------
//struct v8nm8s {VEC_NM8S(8)};
typedef struct s_v8nm8s {
    unsigned long long vec[1];
}v8nm8s ;
//-----------------------------------------------------------------------------
//struct v16nm8s {VEC_NM8S(16)};
typedef struct s_v16nm8s {
    unsigned long long vec[2];
} v16nm8s;
//-----------------------------------------------------------------------------
//struct  v4nm16s {VEC_NM16S(4)};
typedef struct  s_v4nm16s {
    unsigned long long vec[1];
} v4nm16s;
 
 
//-----------------------------------------------------------------------------
//struct v8nm16s {VEC_NM16S(8)};
typedef struct s_v8nm16s {
    unsigned long long vec[2];
}v8nm16s ;
//-----------------------------------------------------------------------------
//struct v16nm16s {VEC_NM16S(16)};
typedef struct s_v16nm16s {
    unsigned long long vec[4];
}v16nm16s ;
 
//-----------------------------------------------------------------------------
//struct v2nm32s {VEC_NM32S(2)};
typedef struct s_v2nm32s {
    unsigned long long vec[1];
}v2nm32s ;
//-----------------------------------------------------------------------------
//struct v4nm32s {VEC_NM32S(4)};
typedef struct s_v4nm32s {
    unsigned long long vec[2];
} v4nm32s ;
//-----------------------------------------------------------------------------
//struct v8nm32s {VEC_NM32S(8)  };
typedef struct s_v8nm32s {
    unsigned long long vec[4];
} v8nm32s ;
//-----------------------------------------------------------------------------
//struct v16nm32s {VEC_NM32S(16)    };
typedef struct s_v16nm32s {
    unsigned long long vec[8];
}v16nm32s ;
//-----------------------------------------------------------------------------
typedef v16nm8s v16nm8s7b;
 
//=============================================================================
 
//-----------------------------------------------------------------------------
//struct v16nm4u {VEC_NM4U(16)  };
typedef struct s_v16nm4u {
    unsigned long long vec[1];
} v16nm4u;
//-----------------------------------------------------------------------------
//struct v4nm8u {VEC_NM8U(4)        };
typedef struct s_v4nm8u {
    unsigned long long vec[1];
} v4nm8u;
//-----------------------------------------------------------------------------
//struct v8nm8u {VEC_NM8U(8)        };
typedef struct s_v8nm8u {
    unsigned long long vec[1];
}v8nm8u;
//-----------------------------------------------------------------------------
//struct v16nm8u {VEC_NM8U(16)  };
typedef struct s_v16nm8u {
    unsigned long long vec[2];
} v16nm8u;
//-----------------------------------------------------------------------------
//struct v4nm16u {VEC_NM16U(4)  };
typedef struct s_v4nm16u {
    unsigned long long vec[1];
} v4nm16u;
//-----------------------------------------------------------------------------
//struct v8nm16u {VEC_NM16U(8)  };
typedef struct s_v8nm16u {
    unsigned long long vec[2];
} v8nm16u;
//-----------------------------------------------------------------------------
//struct v16nm16u {VEC_NM16U(16)    };
typedef struct s_v16nm16u {
    unsigned long long vec[4];
}v16nm16u;
//-----------------------------------------------------------------------------
//struct v2nm32u {VEC_NM32U(2)  };
typedef struct s_v2nm32u {
    unsigned long long vec[1];
}v2nm32u ;
//-----------------------------------------------------------------------------
//struct v4nm32u {VEC_NM32U(4)  };
typedef struct s_v4nm32u {
    unsigned long long vec[2];
}v4nm32u;
//-----------------------------------------------------------------------------
//struct v8nm32u {VEC_NM32U(8)  };
typedef struct s_v8nm32u {
    unsigned long long vec[4];
} v8nm32u;
//-----------------------------------------------------------------------------
//struct v16nm32u {VEC_NM32U(16)    };
typedef struct s_v16nm32u {
    unsigned long long vec[8];
} v16nm32u;
//-----------------------------------------------------------------------------
 
typedef v16nm4u v16nm4b3u;
//=============================================================================
//-----------------------------------------------------------------------------
struct nm16sc
{
 
    signed short r;
    signed short c;
 
    //nm16sc() : r(0), c(0) {}
    //nm16sc(nm16s b) : r(b), c(0) {}
};
//-----------------------------------------------------------------------------
typedef struct s_nm32sc
{
 
    nm32s re;
    nm32s im;
 
    //nm32sc() : re(0), im(0) {}
    //nm32sc(nm32s b) : re(b), im(0) {}
}nm32sc;
 
typedef struct s_v2nm32f
{
    float v0;
    float v1;
} v2nm32f;
 
typedef struct s_v4nm32f
{
    float vec[4];
} v4nm32f;
 
typedef struct s_v4nm64f
{
    double vec[4];
} v4nm64f;
 
 
typedef struct s_nm32fc
{
    float re;
    float im;
}nm32fc;
 
 
typedef struct s_nm32fcr
{
 
    float im;
    float re;
 
    //nm32sc() : re(0), im(0) {}
    //nm32sc(nm32s b) : re(b), im(0) {}
}nm32fcr;
 
typedef float  nm32f;
typedef double nm64f;
 
//-----------------------------------------------------------------------------
 
typedef struct s_nm64sc
{
 
    long long re;
 
    long long im;
//
//  nm64sc() : re(0), im(0) {}
//  nm64sc(nm64s b) : re(b), im(0) {}
//
//  int Print();
//
} nm64sc;
 
#ifndef uint64
typedef unsigned long long uint64;
#endif
 
#ifndef uint32
typedef unsigned int uint32;
#endif
 
typedef nm64sc int64sc;
typedef uint64 fifo64;
typedef uint32 fseq32;
 
 
typedef uint64  seq64;
typedef uint64 fseq64;
 
    typedef struct {
        void* buffer0;
        void* buffer1;
        fseq64  route;
        int mode;
        int status;
    } Tmp2BuffSpec;
 
//
//__INLINE__ int NM_CAPACITY(nm1*)  {return 64;}
//
//__INLINE__ int NM_CAPACITY(nm2s*)  {return 32;}
//__INLINE__ int NM_CAPACITY(nm4s*)  {return 16;}
//__INLINE__ int NM_CAPACITY(nm8s*)  {return 8;}
//__INLINE__ int NM_CAPACITY(nm16s*) {return 4;}
//__INLINE__ int NM_CAPACITY(nm32s*) {return 2;}
//__INLINE__ int NM_CAPACITY(nm64s*) {return 1;}
//
//__INLINE__ int NM_CAPACITY(nm2u*)  {return 32;}
//__INLINE__ int NM_CAPACITY(nm4u*)  {return 16;}
//__INLINE__ int NM_CAPACITY(nm8u*)  {return 8;}
//__INLINE__ int NM_CAPACITY(nm16u*) {return 4;}
//__INLINE__ int NM_CAPACITY(nm32u*) {return 2;}
//__INLINE__ int NM_CAPACITY(nm64u*) {return 1;}
//*/
#define CAPACITY_nm64s 1
#define CAPACITY_nm32s 2
#define CAPACITY_nm16s 4
#define CAPACITY_nm8s 8
#define CAPACITY_nm4s 16
#define CAPACITY_nm2s 32
#define CAPACITY_nm1 64
 
//#ifdef __NM__
#define NM16S(vec,size)  nm64s vec##__64s[size/4]; nm16s* vec=(nm16s*)vec##__64s
//#else
//#define NM16S(vec,size)  nm16s vec[size];
//#endif
 
//#ifdef __NM__
#define NM32S(vec,size)  nm64s vec##__64s[size/2]; nm32s* vec=(nm32s*)vec##__64s
//#else
//#define NM32S(vec,size)  nm32s vec[size];
//#endif
 
/*
#ifdef __NM__
#define MTR16S(mtr,ydim,xdim)  static nm64s mtr##__64s[ydim][xdim/4]; nm16s* mtrvec=(nm16s*)vec##__64s
#else
#define MTR16S(mtr,ydim,xdim)  nm16s vec[size];
#endif
*/
//
//
#ifdef __cplusplus
#define __INLINE__ static inline //  because  1>d:\git\nmpp\include\nmchar.h(17) : error C2574 : 'nmchar::nmchar(void)' : cannot be declared static
//#define __INLINE__  inline
#else
 #ifdef __NM__
   #define __INLINE__ static inline
 #else
   #define __INLINE__ static __inline
  #endif
#endif
 
#define NM16Sx4(x0,x1,x2,x3)    ((long long)(x3&0xFFFFl)<<48)| \
                                ((long long)(x2&0xFFFFl)<<32)| \
                                ((long long)(x1&0xFFFFl)<<16)| \
                                ((long long)(x0&0xFFFFl))
#define NM32Sx2(x0,x1)          ((long long)(unsigned(x1))<<32)| \
                                ((long long)(unsigned(x0)))
#define NM32Sx4(x0,x1,x2,x3)    NM32Sx2(x0,x1),NM32Sx2(x2,x3)
 
#endif
 
 // _NMTYPE_H_INCLUDED_