Added initial version of simd objects.

dlib/simd.h

+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_SIMd_H__
+#define DLIB_SIMd_H__
+
+#include "simd/simd4f.h"
+#include "simd/simd4i.h"
+#include "simd/simd8f.h"
+
+#endif // DLIB_SIMd_H__
+

dlib/simd/simd4f.h

+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_sIMD4F_H__
+#define DLIB_sIMD4F_H__
+
+#include "simd_check.h"
+#include "simd4i.h"
+#include <cmath>
+#include <iostream>
+
+namespace dlib
+{
+
+#ifdef DLIB_HAVE_SSE2
+    class simd4f
+    {
+    public:
+        typedef float type;
+
+        simd4f() {}
+        simd4f(float f) { x = _mm_set1_ps(f); }
+        simd4f(float r0, float r1, float r2, float r3) { x = _mm_setr_ps(r0,r1,r2,r3); }
+        simd4f(const __m128& val):x(val) {}
+        simd4f(const simd4i& val):x(_mm_cvtepi32_ps(val)) {}
+
+        simd4f& operator=(const __m128& val)
+        {
+            x = val;
+            return *this;
+        }
+
+        operator __m128() const { return x; }
+
+        void load_aligned(const type* ptr)  { x = _mm_load_ps(ptr); }
+        void store_aligned(type* ptr) const { _mm_store_ps(ptr, x); }
+        void load(const type* ptr)          { x = _mm_loadu_ps(ptr); }
+        void store(type* ptr)         const { _mm_storeu_ps(ptr, x); }
+
+        unsigned int size() const { return 4; }
+        float operator[](unsigned int idx) const 
+        {
+            float temp[4];
+            store(temp);
+            return temp[idx];
+        }
+
+    private:
+        __m128 x;
+    };
+
+    class simd4f_bool
+    {
+    public:
+        typedef float type;
+
+        simd4f_bool() {}
+        simd4f_bool(const __m128& val):x(val) {}
+
+        simd4f_bool& operator=(const __m128& val)
+        {
+            x = val;
+            return *this;
+        }
+
+        operator __m128() const { return x; }
+
+
+    private:
+        __m128 x;
+    };
+#else
+    class simd4f
+    {
+    public:
+        typedef float type;
+
+        simd4f() {}
+        simd4f(float f) { x[0]=f; x[1]=f; x[2]=f; x[3]=f; }
+        simd4f(float r0, float r1, float r2, float r3) { x[0]=r0; x[1]=r1; x[2]=r2; x[3]=r3;}
+        simd4f(const simd4i& val) { x[0]=val[0]; x[1]=val[1]; x[2]=val[2]; x[3]=val[3];}
+
+        void load_aligned(const type* ptr)
+        {
+            x[0] = ptr[0];
+            x[1] = ptr[1];
+            x[2] = ptr[2];
+            x[3] = ptr[3];
+        }
+
+        void store_aligned(type* ptr) const
+        {
+            ptr[0] = x[0];
+            ptr[1] = x[1];
+            ptr[2] = x[2];
+            ptr[3] = x[3];
+        }
+
+        void load(const type* ptr)
+        {
+            x[0] = ptr[0];
+            x[1] = ptr[1];
+            x[2] = ptr[2];
+            x[3] = ptr[3];
+        }
+
+        void store(type* ptr) const
+        {
+            ptr[0] = x[0];
+            ptr[1] = x[1];
+            ptr[2] = x[2];
+            ptr[3] = x[3];
+        }
+
+        unsigned int size() const { return 4; }
+        float operator[](unsigned int idx) const { return x[idx]; }
+
+    private:
+        float x[4];
+    };
+
+    class simd4f_bool
+    {
+    public:
+        typedef float type;
+
+        simd4f_bool() {}
+        simd4f_bool(bool r0, bool r1, bool r2, bool r3) { x[0]=r0; x[1]=r1; x[2]=r2; x[3]=r3;}
+
+        bool operator[](unsigned int idx) const { return x[idx]; }
+    private:
+        bool x[4];
+    };
+#endif
+
+// ----------------------------------------------------------------------------------------
+
+    inline std::ostream& operator<<(std::ostream& out, const simd4f& item)
+    {
+        float temp[4];
+        item.store(temp);
+        out << "(" << temp[0] << ", " << temp[1] << ", " << temp[2] << ", " << temp[3] << ")";
+        return out;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f operator+ (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_add_ps(lhs, rhs); 
+#else
+        return simd4f(lhs[0]+rhs[0],
+                      lhs[1]+rhs[1],
+                      lhs[2]+rhs[2],
+                      lhs[3]+rhs[3]);
+#endif
+    }
+    inline simd4f& operator+= (simd4f& lhs, const simd4f& rhs) 
+    { return lhs = lhs + rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f operator- (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_sub_ps(lhs, rhs); 
+#else
+        return simd4f(lhs[0]-rhs[0],
+                      lhs[1]-rhs[1],
+                      lhs[2]-rhs[2],
+                      lhs[3]-rhs[3]);
+#endif
+    }
+    inline simd4f& operator-= (simd4f& lhs, const simd4f& rhs) 
+    { return lhs = lhs - rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f operator* (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_mul_ps(lhs, rhs); 
+#else
+        return simd4f(lhs[0]*rhs[0],
+                      lhs[1]*rhs[1],
+                      lhs[2]*rhs[2],
+                      lhs[3]*rhs[3]);
+#endif
+    }
+    inline simd4f& operator*= (simd4f& lhs, const simd4f& rhs) 
+    { return lhs = lhs * rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f operator/ (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_div_ps(lhs, rhs); 
+#else
+        return simd4f(lhs[0]/rhs[0],
+                      lhs[1]/rhs[1],
+                      lhs[2]/rhs[2],
+                      lhs[3]/rhs[3]);
+#endif
+    }
+    inline simd4f& operator/= (simd4f& lhs, const simd4f& rhs) 
+    { return lhs = lhs / rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f_bool operator== (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_cmpeq_ps(lhs, rhs); 
+#else
+        return simd4f_bool(lhs[0]==rhs[0],
+                           lhs[1]==rhs[1],
+                           lhs[2]==rhs[2],
+                           lhs[3]==rhs[3]);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f_bool operator!= (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_cmpneq_ps(lhs, rhs); 
+#else
+        return simd4f_bool(lhs[0]!=rhs[0],
+                           lhs[1]!=rhs[1],
+                           lhs[2]!=rhs[2],
+                           lhs[3]!=rhs[3]);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f_bool operator< (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_cmplt_ps(lhs, rhs); 
+#else
+        return simd4f_bool(lhs[0]<rhs[0],
+                           lhs[1]<rhs[1],
+                           lhs[2]<rhs[2],
+                           lhs[3]<rhs[3]);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f_bool operator> (const simd4f& lhs, const simd4f& rhs) 
+    { 
+        return rhs < lhs;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f_bool operator<= (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_cmple_ps(lhs, rhs); 
+#else
+        return simd4f_bool(lhs[0]<=rhs[0],
+                           lhs[1]<=rhs[1],
+                           lhs[2]<=rhs[2],
+                           lhs[3]<=rhs[3]);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f_bool operator>= (const simd4f& lhs, const simd4f& rhs) 
+    { 
+        return rhs <= lhs;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f min (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_min_ps(lhs, rhs); 
+#else
+        return simd4f(std::min(lhs[0],rhs[0]),
+                      std::min(lhs[1],rhs[1]),
+                      std::min(lhs[2],rhs[2]),
+                      std::min(lhs[3],rhs[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f max (const simd4f& lhs, const simd4f& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_max_ps(lhs, rhs); 
+#else
+        return simd4f(std::max(lhs[0],rhs[0]),
+                      std::max(lhs[1],rhs[1]),
+                      std::max(lhs[2],rhs[2]),
+                      std::max(lhs[3],rhs[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f reciprocal (const simd4f& item) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_rcp_ps(item); 
+#else
+        return simd4f(1.0f/item[0],
+                      1.0f/item[1],
+                      1.0f/item[2],
+                      1.0f/item[3]);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f reciprocal_sqrt (const simd4f& item) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_rsqrt_ps(item); 
+#else
+        return simd4f(1.0f/std::sqrt(item[0]),
+                      1.0f/std::sqrt(item[1]),
+                      1.0f/std::sqrt(item[2]),
+                      1.0f/std::sqrt(item[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline float dot(const simd4f& lhs, const simd4f& rhs);
+    inline float sum(const simd4f& item)
+    {
+#ifdef DLIB_HAVE_SSE41
+        return dot(simd4f(1), item);
+#elif defined(DLIB_HAVE_SSE3)
+        simd4f temp = _mm_hadd_ps(item,item);
+        return _mm_cvtss_f32(_mm_hadd_ps(temp,temp));
+#elif defined(DLIB_HAVE_SSE2)
+        simd4f temp = _mm_add_ps(item,_mm_movehl_ps(item,item));
+        simd4f temp2 = _mm_shuffle_ps(temp,temp,1);
+        return _mm_cvtss_f32(_mm_add_ss(temp,temp2));
+#else
+        return item[0]+item[1]+item[2]+item[3];
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline float dot(const simd4f& lhs, const simd4f& rhs)
+    {
+#ifdef DLIB_HAVE_SSE41
+        return _mm_cvtss_f32(_mm_dp_ps(lhs, rhs, 0xff));
+#else
+        return sum(lhs*rhs);
+#endif
+    }
+   
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f sqrt(const simd4f& item)
+    {
+#ifdef DLIB_HAVE_SSE2
+        return _mm_sqrt_ps(item);
+#else
+        return simd4f(std::sqrt(item[0]),
+                      std::sqrt(item[1]),
+                      std::sqrt(item[2]),
+                      std::sqrt(item[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f ceil(const simd4f& item)
+    {
+#ifdef DLIB_HAVE_SSE41
+        return _mm_ceil_ps(item);
+#elif defined(DLIB_HAVE_SSE2)
+        float temp[4];
+        item.store(temp);
+        temp[0] = std::ceil(temp[0]);
+        temp[1] = std::ceil(temp[1]);
+        temp[2] = std::ceil(temp[2]);
+        temp[3] = std::ceil(temp[3]);
+        simd4f temp2;
+        temp2.load(temp);
+        return temp2;
+#else
+        return simd4f(std::ceil(item[0]),
+                      std::ceil(item[1]),
+                      std::ceil(item[2]),
+                      std::ceil(item[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4f floor(const simd4f& item)
+    {
+#ifdef DLIB_HAVE_SSE41
+        return _mm_floor_ps(item);
+#elif defined(DLIB_HAVE_SSE2)
+        float temp[4];
+        item.store(temp);
+        temp[0] = std::floor(temp[0]);
+        temp[1] = std::floor(temp[1]);
+        temp[2] = std::floor(temp[2]);
+        temp[3] = std::floor(temp[3]);
+        simd4f temp2;
+        temp2.load(temp);
+        return temp2;
+#else
+        return simd4f(std::floor(item[0]),
+                      std::floor(item[1]),
+                      std::floor(item[2]),
+                      std::floor(item[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    // perform cmp ? a : b
+    inline simd4f select(const simd4f_bool& cmp, const simd4f& a, const simd4f& b)
+    {
+#ifdef DLIB_HAVE_SSE41
+        return _mm_blendv_ps(b,a,cmp);
+#elif defined(DLIB_HAVE_SSE2)
+        return _mm_or_ps(_mm_and_ps(cmp,a) , _mm_andnot_ps(cmp,b));
+#else
+        return simd4f(cmp[0]?a[0]:b[0],
+                      cmp[1]?a[1]:b[1],
+                      cmp[2]?a[2]:b[2],
+                      cmp[3]?a[3]:b[3]);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_sIMD4F_H__
+

dlib/simd/simd4i.h

+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_sIMD4I_H__
+#define DLIB_sIMD4I_H__
+
+#include "simd_check.h"
+#include "dlib/uintn.h"
+
+namespace dlib
+{
+
+#ifdef DLIB_HAVE_SSE2
+    class simd4i
+    {
+    public:
+        typedef int32 type;
+
+        simd4i() {}
+        simd4i(int32 f) { x = _mm_set1_epi32(f); }
+        simd4i(int32 r0, int32 r1, int32 r2, int32 r3) { x = _mm_setr_epi32(r0,r1,r2,r3); }
+        simd4i(const __m128i& val):x(val) {}
+
+        simd4i& operator=(const __m128i& val)
+        {
+            x = val;
+            return *this;
+        }
+
+        operator __m128i() const { return x; }
+
+        void load_aligned(const type* ptr)  { x = _mm_load_si128((const __m128i*)ptr); }
+        void store_aligned(type* ptr) const { _mm_store_si128((__m128i*)ptr, x); }
+        void load(const type* ptr)          { x = _mm_loadu_si128((const __m128i*)ptr); }
+        void store(type* ptr)         const { _mm_storeu_si128((__m128i*)ptr, x); }
+
+        unsigned int size() const { return 4; }
+        int32 operator[](unsigned int idx) const 
+        {
+            int32 temp[4];
+            store(temp);
+            return temp[idx];
+        }
+
+    private:
+        __m128i x;
+    };
+#else
+    class simd4i
+    {
+    public:
+        typedef int32 type;
+
+        simd4i() {}
+        simd4i(int32 f) { x[0]=f; x[1]=f; x[2]=f; x[3]=f; }
+        simd4i(int32 r0, int32 r1, int32 r2, int32 r3) { x[0]=r0; x[1]=r1; x[2]=r2; x[3]=r3;}
+
+        void load_aligned(const type* ptr)
+        {
+            x[0] = ptr[0];
+            x[1] = ptr[1];
+            x[2] = ptr[2];
+            x[3] = ptr[3];
+        }
+
+        void store_aligned(type* ptr) const
+        {
+            ptr[0] = x[0];
+            ptr[1] = x[1];
+            ptr[2] = x[2];
+            ptr[3] = x[3];
+        }
+
+        void load(const type* ptr)
+        {
+            x[0] = ptr[0];
+            x[1] = ptr[1];
+            x[2] = ptr[2];
+            x[3] = ptr[3];
+        }
+
+        void store(type* ptr) const
+        {
+            ptr[0] = x[0];
+            ptr[1] = x[1];
+            ptr[2] = x[2];
+            ptr[3] = x[3];
+        }
+
+        unsigned int size() const { return 4; }
+        int32 operator[](unsigned int idx) const { return x[idx]; }
+
+    private:
+        int32 x[4];
+    };
+#endif
+
+// ----------------------------------------------------------------------------------------
+
+    inline std::ostream& operator<<(std::ostream& out, const simd4i& item)
+    {
+        int32 temp[4];
+        item.store(temp);
+        out << "(" << temp[0] << ", " << temp[1] << ", " << temp[2] << ", " << temp[3] << ")";
+        return out;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator+ (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_add_epi32(lhs, rhs); 
+#else
+        return simd4i(lhs[0]+rhs[0],
+                      lhs[1]+rhs[1],
+                      lhs[2]+rhs[2],
+                      lhs[3]+rhs[3]);
+#endif
+    }
+    inline simd4i& operator+= (simd4i& lhs, const simd4i& rhs) 
+    { return lhs = lhs + rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator- (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_sub_epi32(lhs, rhs); 
+#else
+        return simd4i(lhs[0]-rhs[0],
+                      lhs[1]-rhs[1],
+                      lhs[2]-rhs[2],
+                      lhs[3]-rhs[3]);
+#endif
+    }
+    inline simd4i& operator-= (simd4i& lhs, const simd4i& rhs) 
+    { return lhs = lhs - rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator* (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE41
+        return _mm_mullo_epi32(lhs, rhs); 
+#elif defined(DLIB_HAVE_SSE2)
+        int32 _lhs[4]; lhs.store(_lhs);
+        int32 _rhs[4]; rhs.store(_rhs);
+        return simd4i(_lhs[0]*_rhs[0],
+                      _lhs[1]*_rhs[1],
+                      _lhs[2]*_rhs[2],
+                      _lhs[3]*_rhs[3]);
+#else
+        return simd4i(lhs[0]*rhs[0],
+                      lhs[1]*rhs[1],
+                      lhs[2]*rhs[2],
+                      lhs[3]*rhs[3]);
+#endif
+    }
+    inline simd4i& operator*= (simd4i& lhs, const simd4i& rhs) 
+    { return lhs = lhs * rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator& (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_and_si128(lhs, rhs); 
+#else
+        return simd4i(lhs[0]&rhs[0],
+                      lhs[1]&rhs[1],
+                      lhs[2]&rhs[2],
+                      lhs[3]&rhs[3]);
+#endif
+    }
+    inline simd4i& operator&= (simd4i& lhs, const simd4i& rhs) 
+    { return lhs = lhs & rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator| (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_or_si128(lhs, rhs); 
+#else
+        return simd4i(lhs[0]|rhs[0],
+                      lhs[1]|rhs[1],
+                      lhs[2]|rhs[2],
+                      lhs[3]|rhs[3]);
+#endif
+    }
+    inline simd4i& operator|= (simd4i& lhs, const simd4i& rhs) 
+    { return lhs = lhs | rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator^ (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_xor_si128(lhs, rhs); 
+#else
+        return simd4i(lhs[0]^rhs[0],
+                      lhs[1]^rhs[1],
+                      lhs[2]^rhs[2],
+                      lhs[3]^rhs[3]);
+#endif
+    }
+    inline simd4i& operator^= (simd4i& lhs, const simd4i& rhs) 
+    { return lhs = lhs ^ rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator~ (const simd4i& lhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_xor_si128(lhs, _mm_set1_epi32(0xFFFFFFFF)); 
+#else
+        return simd4i(~lhs[0],
+                      ~lhs[1],
+                      ~lhs[2],
+                      ~lhs[3]);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator<< (const simd4i& lhs, const int& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_sll_epi32(lhs,_mm_cvtsi32_si128(rhs));
+#else
+        return simd4i(lhs[0]<<rhs,
+                      lhs[1]<<rhs,
+                      lhs[2]<<rhs,
+                      lhs[3]<<rhs);
+#endif
+    }
+    inline simd4i& operator<<= (simd4i& lhs, const int& rhs) 
+    { return lhs = lhs << rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator>> (const simd4i& lhs, const int& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_sra_epi32(lhs,_mm_cvtsi32_si128(rhs));
+#else
+        return simd4i(lhs[0]<<rhs,
+                      lhs[1]<<rhs,
+                      lhs[2]<<rhs,
+                      lhs[3]<<rhs);
+#endif
+    }
+    inline simd4i& operator>>= (simd4i& lhs, const int& rhs) 
+    { return lhs = lhs >> rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator== (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_cmpeq_epi32(lhs, rhs); 
+#else
+        return simd4i(lhs[0]==rhs[0] ? 0xFFFFFFFF : 0,
+                      lhs[1]==rhs[1] ? 0xFFFFFFFF : 0,
+                      lhs[2]==rhs[2] ? 0xFFFFFFFF : 0,
+                      lhs[3]==rhs[3] ? 0xFFFFFFFF : 0);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator!= (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return ~(lhs==rhs);
+#else
+        return simd4i(lhs[0]!=rhs[0] ? 0xFFFFFFFF : 0,
+                      lhs[1]!=rhs[1] ? 0xFFFFFFFF : 0,
+                      lhs[2]!=rhs[2] ? 0xFFFFFFFF : 0,
+                      lhs[3]!=rhs[3] ? 0xFFFFFFFF : 0);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator< (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return _mm_cmplt_epi32(lhs, rhs); 
+#else
+        return simd4i(lhs[0]<rhs[0] ? 0xFFFFFFFF : 0,
+                      lhs[1]<rhs[1] ? 0xFFFFFFFF : 0,
+                      lhs[2]<rhs[2] ? 0xFFFFFFFF : 0,
+                      lhs[3]<rhs[3] ? 0xFFFFFFFF : 0);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator> (const simd4i& lhs, const simd4i& rhs) 
+    { 
+        return rhs < lhs;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator<= (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE2
+        return ~(lhs > rhs); 
+#else
+        return simd4i(lhs[0]<=rhs[0] ? 0xFFFFFFFF : 0,
+                      lhs[1]<=rhs[1] ? 0xFFFFFFFF : 0,
+                      lhs[2]<=rhs[2] ? 0xFFFFFFFF : 0,
+                      lhs[3]<=rhs[3] ? 0xFFFFFFFF : 0);
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i operator>= (const simd4i& lhs, const simd4i& rhs) 
+    { 
+        return rhs <= lhs;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i min (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE41
+        return _mm_min_epi32(lhs, rhs); 
+#elif defined(DLIB_HAVE_SSE2)
+        int32 _lhs[4]; lhs.store(_lhs);
+        int32 _rhs[4]; rhs.store(_rhs);
+        return simd4i(std::min(_lhs[0],_rhs[0]),
+                      std::min(_lhs[1],_rhs[1]),
+                      std::min(_lhs[2],_rhs[2]),
+                      std::min(_lhs[3],_rhs[3]));
+#else
+        return simd4i(std::min(lhs[0],rhs[0]),
+                      std::min(lhs[1],rhs[1]),
+                      std::min(lhs[2],rhs[2]),
+                      std::min(lhs[3],rhs[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd4i max (const simd4i& lhs, const simd4i& rhs) 
+    { 
+#ifdef DLIB_HAVE_SSE41
+        return _mm_max_epi32(lhs, rhs); 
+#elif defined(DLIB_HAVE_SSE2)
+        int32 _lhs[4]; lhs.store(_lhs);
+        int32 _rhs[4]; rhs.store(_rhs);
+        return simd4i(std::max(_lhs[0],_rhs[0]),
+                      std::max(_lhs[1],_rhs[1]),
+                      std::max(_lhs[2],_rhs[2]),
+                      std::max(_lhs[3],_rhs[3]));
+#else
+        return simd4i(std::max(lhs[0],rhs[0]),
+                      std::max(lhs[1],rhs[1]),
+                      std::max(lhs[2],rhs[2]),
+                      std::max(lhs[3],rhs[3]));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline int32 sum(const simd4i& item)
+    {
+#ifdef DLIB_HAVE_SSE3
+        simd4i temp = _mm_hadd_epi32(item,item);
+        temp = _mm_hadd_epi32(temp,temp);
+        return _mm_cvtsi128_si32(temp);
+#elif defined(DLIB_HAVE_SSE2)
+        int32 temp[4];
+        item.store(temp);
+        return temp[0]+temp[1]+temp[2]+temp[3];
+#else
+        return item[0]+item[1]+item[2]+item[3];
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    // perform cmp ? a : b
+    inline simd4i select(const simd4i& cmp, const simd4i& a, const simd4i& b)
+    {
+#ifdef DLIB_HAVE_SSE41
+        return _mm_blendv_epi8(b,a,cmp);
+#elif defined(DLIB_HAVE_SSE2)
+        return ((cmp&a) | _mm_andnot_si128(cmp,b));
+#else
+        return ((cmp&a) | (~cmp&b));
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_sIMD4I_H__
+

dlib/simd/simd8f.h

+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_sIMD8F_H__
+#define DLIB_sIMD8F_H__
+
+#include "simd_check.h"
+#include "simd4f.h"
+
+
+namespace dlib
+{
+#ifdef DLIB_HAVE_AVX
+    class simd8f
+    {
+    public:
+        typedef float type;
+
+        simd8f() {}
+        simd8f(const simd4f& low, const simd4f& high)
+        {
+            x = _mm256_insertf128_ps(_mm256_castps128_ps256(low),high,1);
+        }
+        simd8f(float f) { x = _mm256_set1_ps(f); }
+        inline simd8f(float r0, float r1, float r2, float r3, float r4, float r5, float r6, float r7) 
+        { x = _mm256_setr_ps(r0,r1,r2,r3,r4,r5,r6,r7); }
+
+        simd8f(const __m256& val):x(val) {}
+        simd8f& operator=(const __m256& val)
+        {
+            x = val;
+            return *this;
+        }
+        inline operator __m256() const { return x; }
+
+        void load_aligned(const type* ptr)  { x = _mm256_load_ps(ptr); }
+        void store_aligned(type* ptr) const { _mm256_store_ps(ptr, x); }
+        void load(const type* ptr)          { x = _mm256_loadu_ps(ptr); }
+        void store(type* ptr)         const { _mm256_storeu_ps(ptr, x); }
+
+        unsigned int size() const { return 8; }
+        float operator[](unsigned int idx) const 
+        {
+            float temp[8];
+            store(temp);
+            return temp[idx];
+        }
+
+        simd4f low() const { return _mm256_castps256_ps128(x); }
+        simd4f high() const { return _mm256_extractf128_ps(x,1); }
+
+    private:
+        __m256 x;
+    };
+#else
+    class simd8f
+    {
+    public:
+        typedef float type;
+
+        simd8f() {}
+        simd8f(const simd4f& low_, const simd4f& high_): _low(low_),_high(high_){}
+        simd8f(float f) :_low(f),_high(f) {}
+        simd8f(float r0, float r1, float r2, float r3, float r4, float r5, float r6, float r7) :
+            _low(r0,r1,r2,r3), _high(r4,r5,r6,r7) {}
+
+        void load_aligned(const type* ptr)  { _low.load_aligned(ptr); _high.load_aligned(ptr+4); }
+        void store_aligned(type* ptr) const { _low.store_aligned(ptr); _high.store_aligned(ptr+4); }
+        void load(const type* ptr)          { _low.load(ptr); _high.load(ptr+4); }
+        void store(type* ptr)         const { _low.store(ptr); _high.store(ptr+4); }
+
+        unsigned int size() const { return 8; }
+        float operator[](unsigned int idx) const 
+        {
+            if (idx < 4)
+                return _low[idx];
+            else
+                return _high[idx-4];
+        }
+
+        simd4f low() const { return _low; }
+        simd4f high() const { return _high; }
+
+    private:
+        simd4f _low, _high;
+    };
+#endif
+
+// ----------------------------------------------------------------------------------------
+
+    inline std::ostream& operator<<(std::ostream& out, const simd8f& item)
+    {
+        float temp[8];
+        item.store(temp);
+        out << "(" << temp[0] << ", " << temp[1] << ", " << temp[2] << ", " << temp[3] << ", "
+                   << temp[4] << ", " << temp[5] << ", " << temp[6] << ", " << temp[7] << ")";
+        return out;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd8f operator+ (const simd8f& lhs, const simd8f& rhs) 
+    { 
+#ifdef DLIB_HAVE_AVX
+        return _mm256_add_ps(lhs, rhs); 
+#else
+        return simd8f(lhs.low()+rhs.low(),
+                      lhs.high()+rhs.high());
+#endif
+    }
+    inline simd8f& operator+= (simd8f& lhs, const simd8f& rhs) 
+    { return lhs = lhs + rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline simd8f operator* (const simd8f& lhs, const simd8f& rhs) 
+    { 
+#ifdef DLIB_HAVE_AVX
+        return _mm256_mul_ps(lhs, rhs); 
+#else
+        return simd8f(lhs.low()*rhs.low(),
+                      lhs.high()*rhs.high());
+#endif
+    }
+    inline simd8f& operator*= (simd8f& lhs, const simd8f& rhs) 
+    { return lhs = lhs * rhs; return lhs;}
+
+// ----------------------------------------------------------------------------------------
+
+    inline float sum(const simd8f& item)
+    {
+#ifdef DLIB_HAVE_AVX
+        simd8f temp = _mm256_hadd_ps(item,item);
+        simd8f temp2 = _mm256_hadd_ps(temp,temp);
+        return _mm_cvtss_f32(_mm_add_ss(_mm256_castps256_ps128(temp2),_mm256_extractf128_ps(temp2,1)));
+#else
+        return sum(item.low()+item.high()); 
+#endif
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    inline float dot(const simd8f& lhs, const simd8f& rhs)
+    {
+        return sum(lhs*rhs);
+    }
+   
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_sIMD8F_H__
+

dlib/simd/simd_check.h

+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_SIMd_CHECK_H__
+#define DLIB_SIMd_CHECK_H__
+
+
+// figure out which SIMD instructions we can use.
+#ifndef DLIB_DO_NOT_USE_SIMD
+    #ifdef _MSC_VER
+        #if _MSC_VER >= 1400
+            #define DLIB_HAVE_SSE2
+        #endif
+        #if _MSC_VER >= 1500
+            #define DLIB_HAVE_SSE3
+            #define DLIB_HAVE_SSE41
+        #endif
+    #else
+        #ifdef __SSE2__
+            #define DLIB_HAVE_SSE2
+        #endif
+        #ifdef __SSE3__
+            #define DLIB_HAVE_SSE3
+        #endif
+        #ifdef __SSE4_1__
+            #define DLIB_HAVE_SSE41
+        #endif
+        #ifdef __AVX__
+            #define DLIB_HAVE_AVX
+        #endif
+    #endif
+#endif
+
+ 
+// ----------------------------------------------------------------------------------------
+
+#ifdef DLIB_HAVE_SSE2
+    #include <xmmintrin.h>
+    #include <emmintrin.h>
+    #include <mmintrin.h>
+#endif
+#ifdef DLIB_HAVE_SSE3
+    #include <pmmintrin.h> // SSE3
+#endif
+#ifdef DLIB_HAVE_SSE41
+    #include <smmintrin.h> // SSE4
+#endif
+#ifdef DLIB_HAVE_AVX
+    #include <immintrin.h> // AVX
+#endif
+
+
+#endif // DLIB_SIMd_CHECK_H__
+
+