Make windows great again

Author: willdealtry

cpp/arcticdb/util/mean.hpp

@@ -4,9 +4,12 @@
 #include <cstddef>
 
 #include <arcticdb/util/vector_common.hpp>
+#include <arcticdb/util/preconditions.hpp>
 
 namespace arcticdb {
 
+#ifndef _WIN32
+
 template<typename T>
 class MeanFinder {
     static_assert(is_supported_int<T>::value || is_supported_float<T>::value, "Unsupported type");
@@ -78,4 +81,15 @@ double find_mean(const T *data, size_t n) {
     return MeanFinder<T>::find(data, n);
 }
 
+#else
+
+template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type>
+double find_mean(const T* data, std::size_t size) {
+    util::check(size > 0, "Cannot compute mean of an empty array.");
+    double sum = std::accumulate(data, data + size, 0.0);
+    return sum / size;
+}
+
+#endif
+
 } // namespace arcticdb

cpp/arcticdb/util/min_max_float.hpp

@@ -7,6 +7,7 @@
 #include <arcticdb/util/vector_common.hpp>
 
 namespace arcticdb {
+#ifndef _WIN32
 
 template<typename T>
 using vector_type __attribute__((vector_size(64))) = T;
@@ -20,24 +21,20 @@ class FloatMinFinder {
     static T find(const T* data, size_t n) {
         using vec_t = vector_type<T>;
 
-        // Initialize min vector with infinity
         vec_t vmin;
         for(size_t i = 0; i < sizeof(vec_t)/sizeof(T); i++) {
             reinterpret_cast<T*>(&vmin)[i] = std::numeric_limits<T>::infinity();
         }
 
-        // Process full vectors
         const vec_t* vdata = reinterpret_cast<const vec_t*>(data);
         const size_t elements_per_vector = sizeof(vec_t) / sizeof(T);
         const size_t vlen = n / elements_per_vector;
 
-        // Main SIMD loop
         for(size_t i = 0; i < vlen; i++) {
             vec_t v = vdata[i];
             vmin = (v < vmin) ? v : vmin;
         }
 
-        // Reduce vector to scalar
         T min_val = std::numeric_limits<T>::infinity();
         const T* min_arr = reinterpret_cast<const T*>(&vmin);
         for(size_t i = 0; i < elements_per_vector; i++) {
@@ -46,7 +43,6 @@ class FloatMinFinder {
             }
         }
 
-        // Handle remainder
         const T* remain = data + (vlen * elements_per_vector);
         for(size_t i = 0; i < n % elements_per_vector; i++) {
             if (remain[i] == remain[i]) {  // Not NaN
@@ -67,24 +63,20 @@ class FloatMaxFinder {
     static T find(const T* data, size_t n) {
         using vec_t = vector_type<T>;
 
-        // Initialize max vector with negative infinity
         vec_t vmax;
         for(size_t i = 0; i < sizeof(vec_t)/sizeof(T); i++) {
             reinterpret_cast<T*>(&vmax)[i] = -std::numeric_limits<T>::infinity();
         }
 
-        // Process full vectors
         const vec_t* vdata = reinterpret_cast<const vec_t*>(data);
         const size_t elements_per_vector = sizeof(vec_t) / sizeof(T);
         const size_t vlen = n / elements_per_vector;
 
-        // Main SIMD loop
         for(size_t i = 0; i < vlen; i++) {
             vec_t v = vdata[i];
             vmax = (v > vmax) ? v : vmax;
         }
 
-        // Reduce vector to scalar
         T max_val = -std::numeric_limits<T>::infinity();
         const T* max_arr = reinterpret_cast<const T*>(&vmax);
         for(size_t i = 0; i < elements_per_vector; i++) {
@@ -93,7 +85,6 @@ class FloatMaxFinder {
             }
         }
 
-        // Handle remainder
         const T* remain = data + (vlen * elements_per_vector);
         for(size_t i = 0; i < n % elements_per_vector; i++) {
             if (remain[i] == remain[i]) {  // Not NaN
@@ -115,4 +106,19 @@ T find_float_max(const T *data, size_t n) {
     return FloatMaxFinder<T>::find(data, n);
 }
 
+#else
+
+template<typename T>
+typename std::enable_if<std::is_integral<T>::value, T>::type
+find_float_min(const T *data, size_t n) {
+    return *std::min_element(data, data + n);
+}
+
+template<typename T>
+typename std::enable_if<std::is_integral<T>::value, T>::type
+find_float_max(const T *data, size_t n) {
+    return *std::max_element(data, data + n);
+}
+
+#endif
 } // namespace arcticdb

cpp/arcticdb/util/min_max_integer.hpp

@@ -2,15 +2,14 @@
 #include <limits>
 #include <type_traits>
 #include <cmath>
-
-#include <cstdint>
-#include <limits>
-#include <type_traits>
+#include <algorithm>
 
 #include <arcticdb/util/vector_common.hpp>
 
 namespace arcticdb {
 
+#ifndef WIN32
+
 template<typename T>
 struct MinMax {
     T min;
@@ -175,4 +174,20 @@ T find_max(const T* data, size_t n) {
     return MaxFinder<T>::find(data, n);
 }
 
+#else
+
+template<typename T>
+typename std::enable_if<std::is_integral<T>::value, T>::type
+find_min(const T *data, size_t n) {
+    return *std::min_element(data, data + n);
+}
+
+template<typename T>
+typename std::enable_if<std::is_integral<T>::value, T>::type
+find_max(const T *data, size_t n) {
+    return *std::max_element(data, data + n);
+}
+
+#endif
+
 } // namespace arcticdb

cpp/arcticdb/util/sum.hpp

@@ -8,6 +8,8 @@
 
 namespace arcticdb {
 
+#ifdef _WIN32
+
 template<typename T>
 struct is_supported_type : std::false_type {};
 
@@ -70,4 +72,13 @@ double find_sum(const T *data, size_t n) {
     return SumFinder<T>::find(data, n);
 }
 
+
+#else
+
+template<typename T>
+double find_sum(const T *data, size_t n) {
+    return std::accumulate(data, data + n, T(0));
+}
+
+#endif
 } // namespace arcticdb