@@ -1,7 +1,11 @@

 #ifndef __COGAPS_SIMD_H__

 #define __COGAPS_SIMD_H__

-#if (defined ( __AVX2__ ) || defined ( __AVX__ )) && (!defined(_WIN32) || !defined(WIN32))

+#if defined(_WIN32) || defined(WIN32) || defined(__MINGW32__)

+    #define COGAPS_SIMD_H_DISABLE_SIMD

+#endif

+

+#if (defined ( __AVX2__ ) || defined ( __AVX__ )) && !defined(COGAPS_SIMD_H_DISABLE_SIMD)

     #define SIMD_INC 8

     #define __GAPS_AVX__

@@ -15,7 +19,7 @@

     #define MUL_PACKED(a,b) _mm256_mul_ps(a,b)

     #define DIV_PACKED(a,b) _mm256_div_ps(a,b)

-#elif (defined ( __SSE4_2__ ) || defined ( __SSE4_1__ )) && (!defined(_WIN32) || !defined(WIN32))

+#elif (defined ( __SSE4_2__ ) || defined ( __SSE4_1__ )) && !defined(COGAPS_SIMD_H_DISABLE_SIMD)

     #define SIMD_INC 4

     #define __GAPS_SSE__

@@ -132,5 +136,8 @@ inline float getScalar(gaps_packed_t pf)

 } // namespace simd

 } // namespace gaps

-#endif // __COGAPS_SIMD_H__

+#ifdef COGAPS_SIMD_H_DISABLE_SIMD

+    #undef COGAPS_SIMD_H_DISABLE_SIMD

+#endif

+#endif // __COGAPS_SIMD_H__

@@ -1,7 +1,7 @@

 #ifndef __COGAPS_SIMD_H__

 #define __COGAPS_SIMD_H__

-#if defined ( __AVX2__ ) || defined ( __AVX__ )

+#if (defined ( __AVX2__ ) || defined ( __AVX__ )) && (!defined(_WIN32) || !defined(WIN32))

     #define SIMD_INC 8

     #define __GAPS_AVX__

@@ -15,7 +15,7 @@

     #define MUL_PACKED(a,b) _mm256_mul_ps(a,b)

     #define DIV_PACKED(a,b) _mm256_div_ps(a,b)

-#elif defined ( __SSE4_2__ ) || defined ( __SSE4_1__ )

+#elif (defined ( __SSE4_2__ ) || defined ( __SSE4_1__ )) && (!defined(_WIN32) || !defined(WIN32))

     #define SIMD_INC 4

     #define __GAPS_SSE__

@@ -97,21 +97,15 @@ public:

     float scalar()

     {

     #if defined( __GAPS_AVX__ )

-

         float* ra = reinterpret_cast<float*>(&mData); // NOLINT

         mData = _mm256_hadd_ps(mData, mData);

         mData = _mm256_hadd_ps(mData, mData);

         return ra[0] + ra[4];

-

     #elif defined( __GAPS_SSE__ )

-

         float* ra = reinterpret_cast<float*>(&mData); // NOLINT

         return ra[0] + ra[1] + ra[2] + ra[3];

-

     #else

-

         return mData;

-

     #endif

     }

@@ -123,21 +117,15 @@ private:

 inline float getScalar(gaps_packed_t pf)

 {

     #if defined( __GAPS_AVX__ )

-

         pf = _mm256_hadd_ps(pf, pf);

         pf = _mm256_hadd_ps(pf, pf);

         float* ra = reinterpret_cast<float*>(&pf); // NOLINT

         return ra[0] + ra[4];

-

     #elif defined( __GAPS_SSE__ )

-

         float* ra = reinterpret_cast<float*>(&pf); // NOLINT

         return ra[0] + ra[1] + ra[2] + ra[3];

-

     #else

-

         return pf;

-

     #endif

 }

@@ -3,6 +3,7 @@

 #if defined ( __AVX2__ ) || defined ( __AVX__ )

+    #define SIMD_INC 8

     #define __GAPS_AVX__

     #include <immintrin.h>

     typedef __m256 gaps_packed_t;

@@ -16,6 +17,7 @@

 #elif defined ( __SSE4_2__ ) || defined ( __SSE4_1__ )

+    #define SIMD_INC 4

     #define __GAPS_SSE__

     #include <nmmintrin.h>

     typedef __m128 gaps_packed_t;

@@ -30,6 +32,7 @@

 #else

     typedef float gaps_packed_t;

+    #define SIMD_INC 1

     #define SET_SCALAR(x) x

     #define LOAD_PACKED(x) *(x)

     #define STORE_PACKED(p,x) *(p) = (x)

@@ -58,13 +61,7 @@ public:

     static unsigned increment()

     {

-    #if defined( __GAPS_AVX__ )

-        return 8;

-    #elif defined( __GAPS_SSE__ )

-        return 4;

-    #else

-        return 1;

-    #endif

+        return SIMD_INC;

     }

     friend const float* operator+(const float *ptr, Index ndx);

@@ -82,7 +79,7 @@ class PackedFloat

 {

 public:

-    PackedFloat() : mData() {}

+    PackedFloat() : mData(SET_SCALAR(0.f)) {}

     explicit PackedFloat(float val) : mData(SET_SCALAR(val)) {}

 #if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ ) // avoid redefintion when gaps_packed_t == float

     explicit PackedFloat(gaps_packed_t val) : mData(val) {}

@@ -123,6 +120,27 @@ private:

     gaps_packed_t mData;

 };

+inline float getScalar(gaps_packed_t pf)

+{

+    #if defined( __GAPS_AVX__ )

+

+        pf = _mm256_hadd_ps(pf, pf);

+        pf = _mm256_hadd_ps(pf, pf);

+        float* ra = reinterpret_cast<float*>(&pf); // NOLINT

+        return ra[0] + ra[4];

+

+    #elif defined( __GAPS_SSE__ )

+

+        float* ra = reinterpret_cast<float*>(&pf); // NOLINT

+        return ra[0] + ra[1] + ra[2] + ra[3];

+

+    #else

+

+        return pf;

+

+    #endif

+}

+

 } // namespace simd

 } // namespace gaps

@@ -84,7 +84,7 @@ public:

     PackedFloat() : mData() {}

     explicit PackedFloat(float val) : mData(SET_SCALAR(val)) {}

-#if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ )

+#if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ ) // avoid redefintion when gaps_packed_t == float

     explicit PackedFloat(gaps_packed_t val) : mData(val) {}

 #endif

old mode 100644

new mode 100755

@@ -6,7 +6,6 @@

     #define __GAPS_AVX__

     #include <immintrin.h>

     typedef __m256 gaps_packed_t;

-    const unsigned index_increment = 8;

     #define SET_SCALAR(x) _mm256_set1_ps(x)

     #define LOAD_PACKED(x) _mm256_load_ps(x)

     #define STORE_PACKED(p,x) _mm256_store_ps(p,x)

@@ -20,7 +19,6 @@

     #define __GAPS_SSE__

     #include <nmmintrin.h>

     typedef __m128 gaps_packed_t;

-    const unsigned index_increment = 4;

     #define SET_SCALAR(x) _mm_set1_ps(x)

     #define LOAD_PACKED(x) _mm_load_ps(x)

     #define STORE_PACKED(p,x) _mm_store_ps(p,x)

@@ -32,7 +30,6 @@

 #else

     typedef float gaps_packed_t;

-    const unsigned index_increment = 1;

     #define SET_SCALAR(x) x

     #define LOAD_PACKED(x) *(x)

     #define STORE_PACKED(p,x) *(p) = (x)

@@ -56,9 +53,19 @@ public:

     Index& operator=(unsigned val) { index = val; return *this; }

     bool operator<(unsigned comp) const { return index < comp; }

     bool operator<=(unsigned comp) const { return index <= comp; }

-    void operator++() { index += index_increment; }

+    void operator++() { index += gaps::simd::Index::increment(); }

     unsigned value() const { return index; }

-    unsigned increment() const { return index_increment; }

+    

+    static unsigned increment()

+    {

+    #if defined( __GAPS_AVX__ )

+        return 8;

+    #elif defined( __GAPS_SSE__ )

+        return 4;

+    #else

+        return 1;

+    #endif

+    }

     friend const float* operator+(const float *ptr, Index ndx);

     friend float* operator+(float *ptr, Index ndx);

@@ -1,34 +1,10 @@

 #ifndef __COGAPS_SIMD_H__

 #define __COGAPS_SIMD_H__

-#ifndef SSE_INSTR_SET

-    #if defined ( __AVX2__ )

-        #define SSE_INSTR_SET 8

-    #elif defined ( __AVX__ )

-        #define SSE_INSTR_SET 7

-    #elif defined ( __SSE4_2__ )

-        #define SSE_INSTR_SET 6

-    #elif defined ( __SSE4_1__ )

-        #define SSE_INSTR_SET 5

-    #else

-        #define SSE_INSTR_SET 0

-    #endif

-#endif

+#if defined ( __AVX2__ ) || defined ( __AVX__ )

-#if SSE_INSTR_SET > 6

     #define __GAPS_AVX__

     #include <immintrin.h>

-#elif SSE_INSTR_SET == 6 || SSE_INSTR_SET == 5

-    #define __GAPS_SSE__

-    #include <nmmintrin.h>

-#endif

-

-namespace gaps

-{

-namespace simd

-{

-

-#if defined( __GAPS_AVX__ )

     typedef __m256 gaps_packed_t;

     const unsigned index_increment = 8;

     #define SET_SCALAR(x) _mm256_set1_ps(x)

@@ -38,7 +14,11 @@ namespace simd

     #define SUB_PACKED(a,b) _mm256_sub_ps(a,b)

     #define MUL_PACKED(a,b) _mm256_mul_ps(a,b)

     #define DIV_PACKED(a,b) _mm256_div_ps(a,b)

-#elif defined( __GAPS_SSE__ )

+

+#elif defined ( __SSE4_2__ ) || defined ( __SSE4_1__ )

+

+    #define __GAPS_SSE__

+    #include <nmmintrin.h>

     typedef __m128 gaps_packed_t;

     const unsigned index_increment = 4;

     #define SET_SCALAR(x) _mm_set1_ps(x)

@@ -48,7 +28,9 @@ namespace simd

     #define SUB_PACKED(a,b) _mm_sub_ps(a,b)

     #define MUL_PACKED(a,b) _mm_mul_ps(a,b)

     #define DIV_PACKED(a,b) _mm_div_ps(a,b)

+

 #else

+

     typedef float gaps_packed_t;

     const unsigned index_increment = 1;

     #define SET_SCALAR(x) x

@@ -58,73 +40,80 @@ namespace simd

     #define SUB_PACKED(a,b) ((a)-(b))

     #define MUL_PACKED(a,b) ((a)*(b))

     #define DIV_PACKED(a,b) ((a)/(b))

+

 #endif

-class Index

+namespace gaps

+{

+namespace simd

 {

-private:

-

-    unsigned index;

+class Index

+{

 public:

     explicit Index(unsigned i) : index(i) {}

     Index& operator=(unsigned val) { index = val; return *this; }

-    bool operator<(unsigned comp) { return index < comp; }

-    bool operator<=(unsigned comp) { return index <= comp; }

+    bool operator<(unsigned comp) const { return index < comp; }

+    bool operator<=(unsigned comp) const { return index <= comp; }

     void operator++() { index += index_increment; }

     unsigned value() const { return index; }

     unsigned increment() const { return index_increment; }

+

     friend const float* operator+(const float *ptr, Index ndx);

     friend float* operator+(float *ptr, Index ndx);

+

+private:

+

+    unsigned index;

 };

 inline const float* operator+(const float *ptr, Index ndx) { return ptr + ndx.index; }

 inline float* operator+(float *ptr, Index ndx) { return ptr + ndx.index; }

-class packedFloat

+class PackedFloat

 {

-private:

-

-    gaps_packed_t mData;

-

 public:

-    packedFloat() : mData() {}

-    explicit packedFloat(float val) : mData(SET_SCALAR(val)) {}

-#if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ ) || defined( __GAPS_AVX512__ )

-    explicit packedFloat(gaps_packed_t val) : mData(val) {}

+    PackedFloat() : mData() {}

+    explicit PackedFloat(float val) : mData(SET_SCALAR(val)) {}

+#if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ )

+    explicit PackedFloat(gaps_packed_t val) : mData(val) {}

 #endif

-    packedFloat operator+(packedFloat b) const { return packedFloat(ADD_PACKED(mData, b.mData)); }

-    packedFloat operator-(packedFloat b) const { return packedFloat(SUB_PACKED(mData, b.mData)); }

-    packedFloat operator*(packedFloat b) const { return packedFloat(MUL_PACKED(mData, b.mData)); }

-    packedFloat operator/(packedFloat b) const { return packedFloat(DIV_PACKED(mData, b.mData)); }

+    PackedFloat operator+(PackedFloat b) const { return PackedFloat(ADD_PACKED(mData, b.mData)); }

+    PackedFloat operator-(PackedFloat b) const { return PackedFloat(SUB_PACKED(mData, b.mData)); }

+    PackedFloat operator*(PackedFloat b) const { return PackedFloat(MUL_PACKED(mData, b.mData)); }

+    PackedFloat operator/(PackedFloat b) const { return PackedFloat(DIV_PACKED(mData, b.mData)); }

-    void operator+=(packedFloat val) { mData = ADD_PACKED(mData, val.mData); }

+    void operator+=(PackedFloat val) { mData = ADD_PACKED(mData, val.mData); }

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

     void store(float *ptr) { STORE_PACKED(ptr, mData); }

-#if defined( __GAPS_AVX__ )

     float scalar()

     {

+    #if defined( __GAPS_AVX__ )

+

         float* ra = reinterpret_cast<float*>(&mData); // NOLINT

         mData = _mm256_hadd_ps(mData, mData);

         mData = _mm256_hadd_ps(mData, mData);

         return ra[0] + ra[4];

-    }

-#elif defined( __GAPS_SSE__ )

-    float scalar()

-    {

+

+    #elif defined( __GAPS_SSE__ )

+

         float* ra = reinterpret_cast<float*>(&mData); // NOLINT

         return ra[0] + ra[1] + ra[2] + ra[3];

-    }

-#else

-    float scalar()

-    {

+

+    #else

+

         return mData;

+

+    #endif

     }

-#endif

+

+private:

+

+    gaps_packed_t mData;

 };

 } // namespace simd

@@ -130,47 +130,5 @@ public:

 } // namespace simd

 } // namespace gaps

-#if (defined(_M_AMD64) || defined(_M_X64) || defined(__amd64)) && ! defined(__x86_64__)

-    #define __x86_64__ 1

-#endif

-

-#ifdef _OPENMP

-    #define __GAPS_OPENMP__

-#endif

-

-// used to convert defined macro values into strings

-#define STR_HELPER(x) #x

-#define STR(x) STR_HELPER(x)

-

-inline std::string buildReport()

-{

-#if defined( __clang__ )

-    std::string compiler = "Compiled with Clang\n";

-#elif defined( __INTEL_COMPILER )

-    std::string compiler = "Compiled with Intel ICC/ICPC\n";

-#elif defined( __GNUC__ )

-    std::string compiler = "Compiled with GCC v" + std::string(STR( __GNUC__ ))

-    + "." + std::string(STR( __GNUC_MINOR__ )) + '\n';

-#elif defined( _MSC_VER )

-    std::string compiler = "Compiled with Microsoft Visual Studio\n";

-#endif

-

-#if defined( __GAPS_AVX__ )

-    std::string simd = "SIMD: AVX instructions enabled\n";

-#elif defined( __GAPS_SSE__ )

-    std::string simd = "SIMD: SSE instructions enabled\n";

-#else

-    std::string simd = "SIMD not enabled\n";

-#endif

-

-#ifdef __GAPS_OPENMP__

-    std::string openmp = "Compiled with OpenMP\n";

-#else

-    std::string openmp = "Compiler did not support OpenMP\n";

-#endif

-

-    return compiler + simd + openmp;

-}

-

 #endif // __COGAPS_SIMD_H__

@@ -105,8 +105,6 @@ public:

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

     void store(float *ptr) { STORE_PACKED(ptr, mData); }

-// RTTI may be expensive

-

 #if defined( __GAPS_AVX__ )

     float scalar()

     {

@@ -105,6 +105,8 @@ public:

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

     void store(float *ptr) { STORE_PACKED(ptr, mData); }

+// RTTI may be expensive

+

 #if defined( __GAPS_AVX__ )

     float scalar()

     {

@@ -156,9 +156,9 @@ inline std::string buildReport()

 #endif

 #if defined( __GAPS_AVX__ )

-    std::string simd = "AVX enabled\n";

+    std::string simd = "SIMD: AVX instructions enabled\n";

 #elif defined( __GAPS_SSE__ )

-    std::string simd = "SSE enabled\n";

+    std::string simd = "SIMD: SSE instructions enabled\n";

 #else

     std::string simd = "SIMD not enabled\n";

 #endif

@@ -138,5 +138,39 @@ public:

     #define __GAPS_OPENMP__

 #endif

+// used to convert defined macro values into strings

+#define STR_HELPER(x) #x

+#define STR(x) STR_HELPER(x)

+

+inline std::string buildReport()

+{

+#if defined( __clang__ )

+    std::string compiler = "Compiled with Clang\n";

+#elif defined( __INTEL_COMPILER )

+    std::string compiler = "Compiled with Intel ICC/ICPC\n";

+#elif defined( __GNUC__ )

+    std::string compiler = "Compiled with GCC v" + std::string(STR( __GNUC__ ))

+    + "." + std::string(STR( __GNUC_MINOR__ )) + '\n';

+#elif defined( _MSC_VER )

+    std::string compiler = "Compiled with Microsoft Visual Studio\n";

+#endif

+

+#if defined( __GAPS_AVX__ )

+    std::string simd = "AVX enabled\n";

+#elif defined( __GAPS_SSE__ )

+    std::string simd = "SSE enabled\n";

+#else

+    std::string simd = "SIMD not enabled\n";

+#endif

+

+#ifdef __GAPS_OPENMP__

+    std::string openmp = "Compiled with OpenMP\n";

+#else

+    std::string openmp = "Compiler did not support OpenMP\n";

+#endif

+

+    return compiler + simd + openmp;

+}

+

 #endif // __COGAPS_SIMD_H__

@@ -15,7 +15,7 @@

     #endif

 #endif

-#if SSE_INSTR_SET == 7

+#if SSE_INSTR_SET > 6

     #define __GAPS_AVX__

     #include <immintrin.h>

 #elif SSE_INSTR_SET == 6 || SSE_INSTR_SET == 5

@@ -105,14 +105,7 @@ public:

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

     void store(float *ptr) { STORE_PACKED(ptr, mData); }

-#if defined( __GAPS_AVX512__ )

-    float scalar()

-    {

-        float* ra = reinterpret_cast<float*>(&mData); // NOLINT

-        return ra[0] + ra[1] + ra[2] + ra[3] + ra[4] + ra[5] + ra[6] + ra[7] +

-            ra[8] + ra[9] + ra[10] + ra[11] + ra[12] + ra[13] + ra[14] + ra[15];

-    }

-#elif defined( __GAPS_AVX__ )

+#if defined( __GAPS_AVX__ )

     float scalar()

     {

         float* ra = reinterpret_cast<float*>(&mData); // NOLINT

@@ -116,7 +116,9 @@ public:

     float scalar()

     {

         float* ra = reinterpret_cast<float*>(&mData); // NOLINT

-        return ra[0] + ra[1] + ra[2] + ra[3] + ra[4] + ra[5] + ra[6] + ra[7];

+        mData = _mm256_hadd_ps(mData, mData);

+        mData = _mm256_hadd_ps(mData, mData);

+        return ra[0] + ra[4];

     }

 #elif defined( __GAPS_SSE__ )

     float scalar()

@@ -108,20 +108,20 @@ public:

 #if defined( __GAPS_AVX512__ )

     float scalar()

     {

-        float* ra = reinterpret_cast<float*>(&mData);

+        float* ra = reinterpret_cast<float*>(&mData); // NOLINT

         return ra[0] + ra[1] + ra[2] + ra[3] + ra[4] + ra[5] + ra[6] + ra[7] +

             ra[8] + ra[9] + ra[10] + ra[11] + ra[12] + ra[13] + ra[14] + ra[15];

     }

 #elif defined( __GAPS_AVX__ )

     float scalar()

     {

-        float* ra = reinterpret_cast<float*>(&mData);

+        float* ra = reinterpret_cast<float*>(&mData); // NOLINT

         return ra[0] + ra[1] + ra[2] + ra[3] + ra[4] + ra[5] + ra[6] + ra[7];

     }

 #elif defined( __GAPS_SSE__ )

     float scalar()

     {

-        float* ra = reinterpret_cast<float*>(&mData);

+        float* ra = reinterpret_cast<float*>(&mData); // NOLINT

         return ra[0] + ra[1] + ra[2] + ra[3];

     }

 #else

@@ -1,14 +1,6 @@

 #ifndef __COGAPS_SIMD_H__

 #define __COGAPS_SIMD_H__

-#if (defined(_M_AMD64) || defined(_M_X64) || defined(__amd64)) && ! defined(__x86_64__)

-    #define __x86_64__ 1

-#endif

-

-#ifdef _OPENMP

-    #define __GAPS_OPENMP__

-#endif

-

 #ifndef SSE_INSTR_SET

     #if defined ( __AVX2__ )

         #define SSE_INSTR_SET 8

@@ -26,12 +18,9 @@

 #if SSE_INSTR_SET == 7

     #define __GAPS_AVX__

     #include <immintrin.h>

-#elif SSE_INSTR_SET == 6

+#elif SSE_INSTR_SET == 6 || SSE_INSTR_SET == 5

     #define __GAPS_SSE__

     #include <nmmintrin.h>

-#elif SSE_INSTR_SET == 5

-    #define __GAPS_SSE__

-    #include <smmintrin.h>

 #endif

 namespace gaps

@@ -44,6 +33,7 @@ namespace simd

     const unsigned index_increment = 8;

     #define SET_SCALAR(x) _mm256_set1_ps(x)

     #define LOAD_PACKED(x) _mm256_load_ps(x)

+    #define STORE_PACKED(p,x) _mm256_store_ps(p,x)

     #define ADD_PACKED(a,b) _mm256_add_ps(a,b)

     #define SUB_PACKED(a,b) _mm256_sub_ps(a,b)

     #define MUL_PACKED(a,b) _mm256_mul_ps(a,b)

@@ -102,7 +92,7 @@ public:

     packedFloat() : mData() {}

     explicit packedFloat(float val) : mData(SET_SCALAR(val)) {}

-#if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ )

+#if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ ) || defined( __GAPS_AVX512__ )

     explicit packedFloat(gaps_packed_t val) : mData(val) {}

 #endif

@@ -115,7 +105,14 @@ public:

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

     void store(float *ptr) { STORE_PACKED(ptr, mData); }

-#if defined( __GAPS_AVX__ )

+#if defined( __GAPS_AVX512__ )

+    float scalar()

+    {

+        float* ra = reinterpret_cast<float*>(&mData);

+        return ra[0] + ra[1] + ra[2] + ra[3] + ra[4] + ra[5] + ra[6] + ra[7] +

+            ra[8] + ra[9] + ra[10] + ra[11] + ra[12] + ra[13] + ra[14] + ra[15];

+    }

+#elif defined( __GAPS_AVX__ )

     float scalar()

     {

         float* ra = reinterpret_cast<float*>(&mData);

@@ -138,5 +135,13 @@ public:

 } // namespace simd

 } // namespace gaps

+#if (defined(_M_AMD64) || defined(_M_X64) || defined(__amd64)) && ! defined(__x86_64__)

+    #define __x86_64__ 1

+#endif

+

+#ifdef _OPENMP

+    #define __GAPS_OPENMP__

+#endif

+

 #endif // __COGAPS_SIMD_H__

@@ -5,16 +5,12 @@

     #define __x86_64__ 1

 #endif

-#ifndef _OPENMP

-    #pragma message("Compiler does not support OpenMP")

-#else

+#ifdef _OPENMP

     #define __GAPS_OPENMP__

 #endif

 #ifndef SSE_INSTR_SET

-    #ifndef SIMD

-        #define SSE_INSTR_SET 0

-    #elif defined ( __AVX2__ )

+    #if defined ( __AVX2__ )

         #define SSE_INSTR_SET 8

     #elif defined ( __AVX__ )

         #define SSE_INSTR_SET 7

@@ -23,7 +19,6 @@

     #elif defined ( __SSE4_1__ )

         #define SSE_INSTR_SET 5

     #else

-        #error "SIMD not supported"

         #define SSE_INSTR_SET 0

     #endif

 #endif

@@ -123,13 +123,13 @@ public:

 #if defined( __GAPS_AVX__ )

     float scalar()

     {

-        float* ra = (float*)&mData;

+        float* ra = reinterpret_cast<float*>(&mData);

         return ra[0] + ra[1] + ra[2] + ra[3] + ra[4] + ra[5] + ra[6] + ra[7];

     }

 #elif defined( __GAPS_SSE__ )

     float scalar()

     {

-        float* ra = (float*)&mData;

+        float* ra = reinterpret_cast<float*>(&mData);

         return ra[0] + ra[1] + ra[2] + ra[3];

     }

 #else

@@ -68,7 +68,7 @@ namespace simd

     const unsigned index_increment = 1;

     #define SET_SCALAR(x) x

     #define LOAD_PACKED(x) *(x)

-    #define STORE_PACKED(p,x) *p = x

+    #define STORE_PACKED(p,x) *(p) = (x)

     #define ADD_PACKED(a,b) ((a)+(b))

     #define SUB_PACKED(a,b) ((a)-(b))

     #define MUL_PACKED(a,b) ((a)*(b))

@@ -78,10 +78,13 @@ namespace simd

 class Index

 {

 private:

+

     unsigned index;

+

 public:

-    Index(unsigned i) : index(i) {}

-    void operator=(unsigned val) { index = val; }

+

+    explicit Index(unsigned i) : index(i) {}

+    Index& operator=(unsigned val) { index = val; return *this; }

     bool operator<(unsigned comp) { return index < comp; }

     bool operator<=(unsigned comp) { return index <= comp; }

     void operator++() { index += index_increment; }

@@ -102,16 +105,16 @@ private:

 public:

-    packedFloat() {}

-    packedFloat(float val) : mData(SET_SCALAR(val)) {}

+    packedFloat() : mData() {}

+    explicit packedFloat(float val) : mData(SET_SCALAR(val)) {}

 #if defined( __GAPS_SSE__ ) || defined( __GAPS_AVX__ )

-    packedFloat(gaps_packed_t val) : mData(val) {}

+    explicit packedFloat(gaps_packed_t val) : mData(val) {}

 #endif

-    packedFloat operator+(packedFloat b) const { return ADD_PACKED(mData, b.mData); }

-    packedFloat operator-(packedFloat b) const { return SUB_PACKED(mData, b.mData); }

-    packedFloat operator*(packedFloat b) const { return MUL_PACKED(mData, b.mData); }

-    packedFloat operator/(packedFloat b) const { return DIV_PACKED(mData, b.mData); }

+    packedFloat operator+(packedFloat b) const { return packedFloat(ADD_PACKED(mData, b.mData)); }

+    packedFloat operator-(packedFloat b) const { return packedFloat(SUB_PACKED(mData, b.mData)); }

+    packedFloat operator*(packedFloat b) const { return packedFloat(MUL_PACKED(mData, b.mData)); }

+    packedFloat operator/(packedFloat b) const { return packedFloat(DIV_PACKED(mData, b.mData)); }

     void operator+=(packedFloat val) { mData = ADD_PACKED(mData, val.mData); }

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

@@ -6,7 +6,7 @@

 #endif

 #ifndef _OPENMP

-    #warning "Compiler does not support OpenMP"

+    #pragma message("Compiler does not support OpenMP")

 #else

     #define __GAPS_OPENMP__

 #endif

@@ -69,10 +69,10 @@ namespace simd

     #define SET_SCALAR(x) x

     #define LOAD_PACKED(x) *(x)

     #define STORE_PACKED(p,x) *p = x

-    #define ADD_PACKED(a,b) (a+b)

-    #define SUB_PACKED(a,b) (a-b)

-    #define MUL_PACKED(a,b) (a*b)

-    #define DIV_PACKED(a,b) (a/b)

+    #define ADD_PACKED(a,b) ((a)+(b))

+    #define SUB_PACKED(a,b) ((a)-(b))

+    #define MUL_PACKED(a,b) ((a)*(b))

+    #define DIV_PACKED(a,b) ((a)/(b))

 #endif

 class Index

@@ -5,8 +5,10 @@

     #define __x86_64__ 1

 #endif

-#if !defined(_OPENMP)

+#ifndef _OPENMP

     #warning "Compiler does not support OpenMP"

+#else

+    #define __GAPS_OPENMP__

 #endif

 #ifndef SSE_INSTR_SET

@@ -5,6 +5,10 @@

     #define __x86_64__ 1

 #endif

+#if !defined(_OPENMP)

+    #warning "Compiler does not support OpenMP"

+#endif

+

 #ifndef SSE_INSTR_SET

     #ifndef SIMD

         #define SSE_INSTR_SET 0

@@ -52,6 +52,7 @@ namespace simd

     const unsigned index_increment = 4;

     #define SET_SCALAR(x) _mm_set1_ps(x)

     #define LOAD_PACKED(x) _mm_load_ps(x)

+    #define STORE_PACKED(p,x) _mm_store_ps(p,x)

     #define ADD_PACKED(a,b) _mm_add_ps(a,b)

     #define SUB_PACKED(a,b) _mm_sub_ps(a,b)

     #define MUL_PACKED(a,b) _mm_mul_ps(a,b)

@@ -61,6 +62,7 @@ namespace simd

     const unsigned index_increment = 1;

     #define SET_SCALAR(x) x

     #define LOAD_PACKED(x) *(x)

+    #define STORE_PACKED(p,x) *p = x

     #define ADD_PACKED(a,b) (a+b)

     #define SUB_PACKED(a,b) (a-b)

     #define MUL_PACKED(a,b) (a*b)

@@ -80,9 +82,11 @@ public:

     unsigned value() const { return index; }

     unsigned increment() const { return index_increment; }

     friend const float* operator+(const float *ptr, Index ndx);

+    friend float* operator+(float *ptr, Index ndx);

 };

 inline const float* operator+(const float *ptr, Index ndx) { return ptr + ndx.index; }

+inline float* operator+(float *ptr, Index ndx) { return ptr + ndx.index; }

 class packedFloat

 {

@@ -105,6 +109,7 @@ public:

     void operator+=(packedFloat val) { mData = ADD_PACKED(mData, val.mData); }

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

+    void store(float *ptr) { STORE_PACKED(ptr, mData); }

 #if defined( __GAPS_AVX__ )

     float scalar()

new file mode 100644

@@ -0,0 +1,133 @@

+#ifndef __COGAPS_SIMD_H__

+#define __COGAPS_SIMD_H__

+

+#if (defined(_M_AMD64) || defined(_M_X64) || defined(__amd64)) && ! defined(__x86_64__)

+    #define __x86_64__ 1

+#endif

+

+#ifndef SSE_INSTR_SET

+    #ifndef SIMD

+        #define SSE_INSTR_SET 0

+    #elif defined ( __AVX2__ )