dvec.h

C语言库函数的原型,有用的拿去

        /* Assignment Operator */
        Iu16vec8& operator= (const M128 &a)             { return *this = (Iu16vec8) a; }
        /* Logical Assignment Operators */
        Iu16vec8& operator&=(const M128 &a)             { return *this = (Iu16vec8) _mm_and_si128(vec,a); }
        Iu16vec8& operator|=(const M128 &a)             { return *this = (Iu16vec8) _mm_or_si128(vec,a); }
        Iu16vec8& operator^=(const M128 &a)             { return *this = (Iu16vec8) _mm_xor_si128(vec,a); }
        /* Addition & Subtraction Assignment Operators */
        Iu16vec8& operator +=(const I16vec8 &a) { return *this = (Iu16vec8) _mm_add_epi16(vec,a); }
        Iu16vec8& operator -=(const I16vec8 &a) { return *this = (Iu16vec8) _mm_sub_epi16(vec,a); }
        Iu16vec8& operator *=(const I16vec8 &a) { return *this = (Iu16vec8) _mm_mullo_epi16(vec,a); }

        /* Shift Logical Operators */
        Iu16vec8 operator<<(const M128 &a)                              { return _mm_sll_epi16(vec,a); }
        Iu16vec8 operator<<(int count)                                  { return _mm_slli_epi16(vec,count); }
        Iu16vec8& operator<<=(const M128 &a)                    { return *this = (Iu16vec8)_mm_sll_epi16(vec,a); }
        Iu16vec8& operator<<=(int count)                                { return *this = (Iu16vec8)_mm_slli_epi16(vec,count); }
        Iu16vec8 operator>>(const M128 &a)                              { return _mm_srl_epi16(vec,a); }
        Iu16vec8 operator>>(int count)                                  { return _mm_srli_epi16(vec,count); }
        Iu16vec8& operator>>=(const M128 &a)                    { return *this = (Iu16vec8) _mm_srl_epi16(vec,a); }
        Iu16vec8& operator>>=(int count)                                { return *this = (Iu16vec8) _mm_srli_epi16(vec,count); }


#if defined (_ENABLE_VEC_DEBUG)
        /* Output for Debug */
        friend std::ostream& operator << (std::ostream &os, const Iu16vec8 &a)
        {
                 os << "[7]:"  << unsigned short(_MM_8UW(7,a))
                        << " [6]:" << unsigned short(_MM_8UW(6,a))
                        << " [5]:" << unsigned short(_MM_8UW(5,a))
                        << " [4]:" << unsigned short(_MM_8UW(4,a))
                        << " [3]:" << unsigned short(_MM_8UW(3,a))
                        << " [2]:" << unsigned short(_MM_8UW(2,a))
                        << " [1]:" << unsigned short(_MM_8UW(1,a))
                        << " [0]:" << unsigned short(_MM_8UW(0,a));
                return os;
        }
#endif  /* defined (_ENABLE_VEC_DEBUG) */

        /* Element Access for Debug, No data modified */
        const unsigned short& operator[](int i)const
        {
                _VEC_ASSERT(static_cast<unsigned int>(i) < 8);  /* Only 8 elements to access */
                return _MM_8UW(i,vec);
        }

        /* Element Access for Debug */
        unsigned short& operator[](int i)
        {
                _VEC_ASSERT(static_cast<unsigned int>(i) < 8);  /* Only 8 elements to access */
                return _MM_8UW(i,vec);
        }
};

inline Iu16vec8 operator*(const Iu16vec8 &a, const Iu16vec8 &b) { return _mm_mullo_epi16(a,b); }

/* Additional Iu16vec8 functions: cmpeq,cmpneq, unpacks, sat add/sub */
inline Iu16vec8 cmpeq(const Iu16vec8 &a, const Iu16vec8 &b)     { return _mm_cmpeq_epi16(a,b); }
inline Iu16vec8 cmpneq(const Iu16vec8 &a, const Iu16vec8 &b)    { return _mm_andnot_si128(_mm_cmpeq_epi16(a,b), get_mask128()); }

inline Iu16vec8 unpack_low(const Iu16vec8 &a, const Iu16vec8 &b)        { return _mm_unpacklo_epi16(a,b); }
inline Iu16vec8 unpack_high(const Iu16vec8 &a, const Iu16vec8 &b) { return _mm_unpackhi_epi16(a,b); }

inline Iu16vec8 sat_add(const Iu16vec8 &a, const Iu16vec8 &b)   { return _mm_adds_epu16(a,b); }
inline Iu16vec8 sat_sub(const Iu16vec8 &a, const Iu16vec8 &b)   { return _mm_subs_epu16(a,b); }

inline Iu16vec8 simd_avg(const Iu16vec8 &a, const Iu16vec8 &b)  { return _mm_avg_epu16(a,b); }
inline I16vec8 mul_high(const Iu16vec8 &a, const Iu16vec8 &b)   { return _mm_mulhi_epu16(a,b); }

/* I8vec16 Class:
 * 16 elements, each element either unsigned or signed char
 */
class I8vec16 : public M128
{
public:
        I8vec16() { }
        I8vec16(__m128i mm) : M128(mm) { }

        /* Assignment Operator */
        I8vec16& operator= (const M128 &a)              { return *this = (I8vec16) a; }

        /* Logical Assignment Operators */
        I8vec16& operator&=(const M128 &a)              { return *this = (I8vec16) _mm_and_si128(vec,a); }
        I8vec16& operator|=(const M128 &a)              { return *this = (I8vec16) _mm_or_si128(vec,a); }
        I8vec16& operator^=(const M128 &a)              { return *this = (I8vec16) _mm_xor_si128(vec,a); }

        /* Addition & Subtraction Assignment Operators */
        I8vec16& operator +=(const I8vec16 &a)  { return *this = (I8vec16) _mm_add_epi8(vec,a); }
        I8vec16& operator -=(const I8vec16 &a)  { return *this = (I8vec16) _mm_sub_epi8(vec,a); }

};

inline I8vec16 cmpeq(const I8vec16 &a, const I8vec16 &b)                { return _mm_cmpeq_epi8(a,b); }
inline I8vec16 cmpneq(const I8vec16 &a, const I8vec16 &b)               { return _mm_andnot_si128(_mm_cmpeq_epi8(a,b), get_mask128()); }

inline I8vec16 unpack_low(const I8vec16 &a, const I8vec16 &b)   { return _mm_unpacklo_epi8(a,b); }
inline I8vec16 unpack_high(const I8vec16 &a, const I8vec16 &b)  { return _mm_unpackhi_epi8(a,b); }

/* Is8vec16 Class:
 * 16 elements, each element a signed char
 */
class Is8vec16 : public I8vec16
{
public:
        Is8vec16() { }
        Is8vec16(__m128i mm) : I8vec16(mm) { }

        /* Assignment Operator */
        Is8vec16& operator= (const M128 &a)             { return *this = (Is8vec16) a; }

        /* Logical Assignment Operators */
        Is8vec16& operator&=(const M128 &a)             { return *this = (Is8vec16) _mm_and_si128(vec,a); }
        Is8vec16& operator|=(const M128 &a)             { return *this = (Is8vec16) _mm_or_si128(vec,a); }
        Is8vec16& operator^=(const M128 &a)             { return *this = (Is8vec16) _mm_xor_si128(vec,a); }

        /* Addition & Subtraction Assignment Operators */
        Is8vec16& operator +=(const I8vec16 &a) { return *this = (Is8vec16) _mm_add_epi8(vec,a); }
        Is8vec16& operator -=(const I8vec16 &a) { return *this = (Is8vec16) _mm_sub_epi8(vec,a); }

#if defined (_ENABLE_VEC_DEBUG)
        /* Output for Debug */
        friend std::ostream& operator << (std::ostream &os, const Is8vec16 &a)
        {
                 os << "[15]:"  << short(_MM_16B(15,a))
                        << " [14]:" << short(_MM_16B(14,a))
                        << " [13]:" << short(_MM_16B(13,a))
                        << " [12]:" << short(_MM_16B(12,a))
                        << " [11]:" << short(_MM_16B(11,a))
                        << " [10]:" << short(_MM_16B(10,a))
                        << " [9]:" << short(_MM_16B(9,a))
                        << " [8]:" << short(_MM_16B(8,a))
                      << " [7]:" << short(_MM_16B(7,a))
                        << " [6]:" << short(_MM_16B(6,a))
                        << " [5]:" << short(_MM_16B(5,a))
                        << " [4]:" << short(_MM_16B(4,a))
                        << " [3]:" << short(_MM_16B(3,a))
                        << " [2]:" << short(_MM_16B(2,a))
                        << " [1]:" << short(_MM_16B(1,a))
                        << " [0]:" << short(_MM_16B(0,a));
                return os;
        }
#endif  /* defined (_ENABLE_VEC_DEBUG) */

        /* Element Access for Debug, No data modified */
        const signed char& operator[](int i)const
        {
                _VEC_ASSERT(static_cast<unsigned int>(i) < 16); /* Only 16 elements to access */
                return _MM_16B(i,vec);
        }

        /* Element Access for Debug */
        signed char& operator[](int i)
        {
                _VEC_ASSERT(static_cast<unsigned int>(i) < 16); /* Only 16 elements to access */
                return _MM_16B(i,vec);
        }

};

inline Is8vec16 cmpeq(const Is8vec16 &a, const Is8vec16 &b)     { return _mm_cmpeq_epi8(a,b); }
inline Is8vec16 cmpneq(const Is8vec16 &a, const Is8vec16 &b)    { return _mm_andnot_si128(_mm_cmpeq_epi8(a,b), get_mask128()); }
inline Is8vec16 cmpgt(const Is8vec16 &a, const Is8vec16 &b)     { return _mm_cmpgt_epi8(a,b); }
inline Is8vec16 cmplt(const Is8vec16 &a, const Is8vec16 &b)     { return _mm_cmplt_epi8(a,b); }

inline Is8vec16 unpack_low(const Is8vec16 &a, const Is8vec16 &b)        { return _mm_unpacklo_epi8(a,b); }
inline Is8vec16 unpack_high(const Is8vec16 &a, const Is8vec16 &b) { return _mm_unpackhi_epi8(a,b); }

inline Is8vec16 sat_add(const Is8vec16 &a, const Is8vec16 &b)   { return _mm_adds_epi8(a,b); }
inline Is8vec16 sat_sub(const Is8vec16 &a, const Is8vec16 &b)   { return _mm_subs_epi8(a,b); }

/* Iu8vec16 Class:
 * 16 elements, each element a unsigned char
 */
class Iu8vec16 : public I8vec16
{
public:
        Iu8vec16() { }
        Iu8vec16(__m128i mm) : I8vec16(mm) { }

        /* Assignment Operator */
        Iu8vec16& operator= (const M128 &a)             { return *this = (Iu8vec16) a; }

        /* Logical Assignment Operators */
        Iu8vec16& operator&=(const M128 &a)             { return *this = (Iu8vec16) _mm_and_si128(vec,a); }
        Iu8vec16& operator|=(const M128 &a)             { return *this = (Iu8vec16) _mm_or_si128(vec,a); }
        Iu8vec16& operator^=(const M128 &a)             { return *this = (Iu8vec16) _mm_xor_si128(vec,a); }

        /* Addition & Subtraction Assignment Operators */
        Iu8vec16& operator +=(const I8vec16 &a) { return *this = (Iu8vec16) _mm_add_epi8(vec,a); }
        Iu8vec16& operator -=(const I8vec16 &a) { return *this = (Iu8vec16) _mm_sub_epi8(vec,a); }

#if defined (_ENABLE_VEC_DEBUG)
        /* Output for Debug */
        friend std::ostream& operator << (std::ostream &os, const Iu8vec16 &a)
        {
                 os << "[15]:"  << unsigned short(_MM_16UB(15,a))
                        << " [14]:" << unsigned short(_MM_16UB(14,a))
                        << " [13]:" << unsigned short(_MM_16UB(13,a))
                        << " [12]:" << unsigned short(_MM_16UB(12,a))
                        << " [11]:" << unsigned short(_MM_16UB(11,a))
                        << " [10]:" << unsigned short(_MM_16UB(10,a))
                        << " [9]:" << unsigned short(_MM_16UB(9,a))
                        << " [8]:" << unsigned short(_MM_16UB(8,a))
                      << " [7]:" << unsigned short(_MM_16UB(7,a))
                        << " [6]:" << unsigned short(_MM_16UB(6,a))
                        << " [5]:" << unsigned short(_MM_16UB(5,a))
                        << " [4]:" << unsigned short(_MM_16UB(4,a))
                        << " [3]:" << unsigned short(_MM_16UB(3,a))
                        << " [2]:" << unsigned short(_MM_16UB(2,a))
                        << " [1]:" << unsigned short(_MM_16UB(1,a))
                        << " [0]:" << unsigned short(_MM_16UB(0,a));
                return os;
        }
#endif  /* defined (_ENABLE_VEC_DEBUG) */

        /* Element Access for Debug, No data modified */
        const unsigned char& operator[](int i)const
        {
                _VEC_ASSERT(static_cast<unsigned int>(i) < 16); /* Only 16 elements to access */
                return _MM_16UB(i,vec);
        }

        /* Element Access for Debug */
        unsigned char& operator[](int i)
        {
                _VEC_ASSERT(static_cast<unsigned int>(i) < 16); /* Only 16 elements to access */
                return _MM_16UB(i,vec);
        }

};

inline Iu8vec16 cmpeq(const Iu8vec16 &a, const Iu8vec16 &b)     { return _mm_cmpeq_epi8(a,b); }
inline Iu8vec16 cmpneq(const Iu8vec16 &a, const Iu8vec16 &b)    { return _mm_andnot_si128(_mm_cmpeq_epi8(a,b), get_mask128()); }

inline Iu8vec16 unpack_low(const Iu8vec16 &a, const Iu8vec16 &b)        { return _mm_unpacklo_epi8(a,b); }
inline Iu8vec16 unpack_high(const Iu8vec16 &a, const Iu8vec16 &b) { return _mm_unpackhi_epi8(a,b); }

inline Iu8vec16 sat_add(const Iu8vec16 &a, const Iu8vec16 &b)   { return _mm_adds_epu8(a,b); }
inline Iu8vec16 sat_sub(const Iu8vec16 &a, const Iu8vec16 &b)   { return _mm_subs_epu8(a,b); }

inline I64vec2 sum_abs(const Iu8vec16 &a, const Iu8vec16 &b)    { return _mm_sad_epu8(a,b); }

inline Iu8vec16 simd_avg(const Iu8vec16 &a, const Iu8vec16 &b)  { return _mm_avg_epu8(a,b); }
inline Iu8vec16 simd_max(const Iu8vec16 &a, const Iu8vec16 &b)  { return _mm_max_epu8(a,b); }
inline Iu8vec16 simd_min(const Iu8vec16 &a, const Iu8vec16 &b)  { return _mm_min_epu8(a,b); }

/* Pack & Saturates */

inline Is16vec8 pack_sat(const Is32vec4 &a, const Is32vec4 &b)  { return _mm_packs_epi32(a,b); }
inline Is8vec16 pack_sat(const Is16vec8 &a, const Is16vec8 &b)  { return _mm_packs_epi16(a,b); }
inline Iu8vec16 packu_sat(const Is16vec8 &a, const Is16vec8 &b) { return _mm_packus_epi16(a,b);}

 /********************************* Logicals ****************************************/
#define IVEC128_LOGICALS(vect,element) \
inline I##vect##vec##element operator& (const I##vect##vec##element &a, const I##vect##vec##element &b) \
{ return _mm_and_si128( a,b); } \
inline I##vect##vec##element operator| (const I##vect##vec##element &a, const I##vect##vec##element &b) \
{ return _mm_or_si128( a,b); } \
inline I##vect##vec##element operator^ (const I##vect##vec##element &a, const I##vect##vec##element &b) \
{ return _mm_xor_si128( a,b); } \
inline I##vect##vec##element andnot (const I##vect##vec##element &a, const I##vect##vec##element &b) \
{ return _mm_andnot_si128( a,b); }

IVEC128_LOGICALS(8,16)
IVEC128_LOGICALS(u8,16)
IVEC128_LOGICALS(s8,16)
IVEC128_LOGICALS(16,8)
IVEC128_LOGICALS(u16,8)
IVEC128_LOGICALS(s16,8)
IVEC128_LOGICALS(32,4)
IVEC128_LOGICALS(u32,4)
IVEC128_LOGICALS(s32,4)
IVEC128_LOGICALS(64,2)
IVEC128_LOGICALS(128,1)
#undef IVEC128_LOGICALS

 /********************************* Add & Sub ****************************************/
#define IVEC128_ADD_SUB(vect,element,opsize) \
inline I##vect##vec##element operator+ (const I##vect##vec##element &a, const I##vect##vec##element &b) \