Merge remote-tracking branch 'refs/remotes/core/feature/vc' into patches

cmake/modules/AddVcFlags.cmake

+# Defines the functions to use VC
+#
+# .. cmake_function:: add_dune_vc_flags
+#
+#    .. cmake_param:: targets
+#       :positional:
+#       :single:
+#       :required:
+#
+#       A list of targets to use VC with.
+#
+
+function(add_dune_vc_flags _targets)
+  if(Vc_FOUND)
+    foreach(_target ${_targets})
+      target_link_libraries(${_target} ${Vc_LIBRARIES})
+      target_compile_options(${_target} PUBLIC ${Vc_ALL_FLAGS})
+      target_include_directories(${_target} SYSTEM PUBLIC ${Vc_INCLUDE_DIR})
+    endforeach(_target ${_targets})
+  endif(Vc_FOUND)
+endfunction(add_dune_vc_flags)
+
+if(Vc_FOUND)
+  dune_register_package_flags(COMPILE_OPTIONS "${Vc_ALL_FLAGS}"
+                              LIBRARIES "${Vc_LIBRARIES}"
+                              INCLUDE_DIRS "${Vc_INCLUDE_DIR}")
+endif(Vc_FOUND)
+set(HAVE_VC ${Vc_FOUND})

cmake/modules/DuneCommonMacros.cmake

@@ -26,3 +26,7 @@ include(AddGMPFlags)
 find_package(Inkscape)
 include(UseInkscape)
 include(FindMProtect)
+
+# try to find the Vc library
+find_package(Vc)
+include(AddVcFlags)

config.h.cmake

@@ -45,6 +45,9 @@
    to facilitate activating and deactivating GMP using compile flags. */
 #cmakedefine HAVE_GMP ENABLE_GMP
 
+/* Define to 1 if you have the Vc library. */
+#cmakedefine HAVE_VC 1
+
 /* Define to 1 if you have the symbol mprotect. */
 #cmakedefine HAVE_MPROTECT 1
 

doc/doxygen/modules.txt

@@ -21,6 +21,15 @@
   @ingroup Utilities
 */
 
+/**
+ @defgroup RangeUtilities Range Utilities
+ @brief Utilities for reduction like operations on ranges
+
+ All these reduction operations work for appropriate ranges and scalar values
+
+ @ingroup Utilities
+*/
+
 /**
   @defgroup StringUtilities String Utilities
   @brief Utility functions for std::string

dune/common/conditional.hh

+#ifndef DUNE_COMMON_CONDITIONAL_HH
+#define DUNE_COMMON_CONDITIONAL_HH
+
+namespace Dune
+{
+
+    /** \brief conditional evaluate
+
+        sometimes call immediate if, evaluates to
+
+        \code
+        if (b)
+           return v1;
+        else
+           return v2;
+        \endcode
+
+        In contrast to if-then-else the cond function can also be
+        evaluated for vector valued SIMD data types, see simd.hh.
+
+        \param b boolean value
+        \param v1 value of b==true
+        \param v2 value of b==false
+    */
+    template<typename T1, typename T2>
+    const T1 cond(bool b, const T1 & v1, const T2 & v2)
+    {
+        return (b ? v1 : v2);
+    }
+
+} // end namespace Dune
+
+#endif // DUNE_COMMON_CONDITIONAL_HH

dune/common/rangeutilities.hh

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+#ifndef DUNE_COMMON_RANGE_UTILITIES_HH
+#define DUNE_COMMON_RANGE_UTILITIES_HH
+
+#include <dune/common/typetraits.hh>
+#include <utility>
+#include <type_traits>
+#include <bitset>
+
+/**
+ * \file
+ * \brief Utilities for reduction like operations on ranges
+ * \author Christian Engwer
+ */
+
+/**
+ * @addtogroup RangeUtilities
+ * @{
+ */
+
+namespace Dune
+{
+  /**
+     \brief compute the maximum value over a range
+
+     overloads for scalar values, and ranges exist
+  */
+  template <typename T,
+            typename std::enable_if<is_range<T>::value, int>::type = 0>
+  typename T::value_type
+  max_value(const T & v) {
+    using std::max;
+    typename T::value_type m;
+    for (const auto & e : v)
+      m = max(e,m);
+    return m;
+  };
+
+  template <typename T,
+            typename std::enable_if<!is_range<T>::value, int>::type = 0>
+  const T & max_value(const T & v) { return v; };
+
+  /**
+     \brief compute the minimum value over a range
+
+     overloads for scalar values, and ranges exist
+   */
+  template <typename T,
+            typename std::enable_if<is_range<T>::value, int>::type = 0>
+  typename T::value_type
+  min_value(const T & v) {
+    using std::min;
+    typename T::value_type m;
+    for (const auto & e : v)
+      m = min(e,m);
+    return m;
+  };
+
+  template <typename T,
+            typename std::enable_if<!is_range<T>::value, int>::type = 0>
+  T & min_value(const T & v) { return v; };
+
+  /**
+     \brief similar to std::bitset<N>::any() return true, if any entries is true
+
+     overloads for scalar values, ranges, and std::bitset<N> exist
+   */
+  template <typename T,
+            typename std::enable_if<is_range<T>::value, int>::type = 0>
+  bool any_true(const T & v) {
+    bool b = false;
+    for (const auto & e : v)
+      b = b or bool(e);
+    return b;
+  };
+
+  template <typename T,
+            typename std::enable_if<!is_range<T>::value, int>::type = 0>
+  bool any_true(const T & v) { return v; };
+
+  template<std::size_t N>
+  bool any_true(const std::bitset<N> & b)
+  {
+    return b.any();
+  }
+
+  /**
+     \brief similar to std::bitset<N>::all() return true, if any entries is true
+
+     overloads for scalar values, ranges, and std::bitset<N> exist
+   */
+  template <typename T,
+            typename std::enable_if<is_range<T>::value, int>::type = 0>
+  bool all_true(const T & v) {
+    bool b = true;
+    for (const auto & e : v)
+      b = b and bool(e);
+    return b;
+  };
+
+  template <typename T,
+            typename std::enable_if<!is_range<T>::value, int>::type = 0>
+  bool all_true(const T & v) { return v; };
+
+  template<std::size_t N>
+  bool all_true(const std::bitset<N> & b)
+  {
+    return b.all();
+  }
+
+}
+
+#endif // DUNE_COMMON_RANGE_UTILITIES_HH

dune/common/simd.hh

+#ifndef DUNE_COMMON_SIMD_HH
+#define DUNE_COMMON_SIMD_HH
+
+#include <dune/common/rangeutilities.hh>
+#include <dune/common/conditional.hh>
+#if HAVE_VC
+#include <Vc/Vc>
+
+namespace Dune
+{
+
+  template<typename T, typename A>
+  Vc::Vector<T,A> cond(const Vc::Mask<T,A> & b,
+    const Vc::Vector<T,A> & v1,
+    const Vc::Vector<T,A> & v2)
+  {
+    return std::move(Vc::iif(b, v1, v2));
+  }
+
+  template<typename T, std::size_t N, typename V, std::size_t M>
+  Vc::SimdArray<T,N,V,M> cond(const typename Vc::SimdArray<T,N,V,M>::mask_type & b,
+    const Vc::SimdArray<T,N,V,M> & v1,
+    const Vc::SimdArray<T,N,V,M> & v2)
+  {
+    return std::move(Vc::iif(b, v1, v2));
+  }
+
+  template<typename T, typename A>
+  T max_value(const Vc::Vector<T,A> & v)
+  {
+    return v.max();
+  }
+
+  template<typename T, std::size_t N, typename V, std::size_t M>
+  double max_value(const Vc::SimdArray<T,N,V,M> & v)
+  {
+    return v.max();
+  }
+
+  template<typename T, typename A>
+  T min_value(const Vc::Vector<T,A> & v)
+  {
+    return v.min();
+  }
+
+  template<typename T, std::size_t N, typename V, std::size_t M>
+  double min_value(const Vc::SimdArray<T,N,V,M> & v)
+  {
+    return v.min();
+  }
+
+  template<typename T, typename A>
+  bool any_true(const Vc::Mask<T,A> & v)
+  {
+    return Vc::any_of(v);
+  }
+
+  template<typename T, std::size_t N, typename V, std::size_t M>
+  bool any_true(const Vc::SimdMaskArray<T,N,V,M> & v)
+  {
+    return Vc::any_of(v);
+  }
+
+  template<typename T, typename A>
+  bool all_true(const Vc::Mask<T,A> & v)
+  {
+    return Vc::all_of(v);
+  }
+
+  template<typename T, std::size_t N, typename V, std::size_t M>
+  bool all_true(const Vc::SimdMaskArray<T,N,V,M> & v)
+  {
+    return Vc::all_of(v);
+  }
+
+} // end namespace Dune
+#endif // HAVE_VC
+
+#endif // DUNE_COMMON_SIMD_HH

dune/common/typetraits.hh

@@ -395,6 +395,25 @@ namespace Dune
 
 #endif // defined(DOXYGEN) or HAVE_IS_INDEXABLE_SUPPORT
 
+  /**
+     typetrait to check that a class has begin() and end() members
+   */
+  // default version, gets picked if SFINAE fails
+  template<typename T, typename = void, typename = void>
+  struct is_range
+    : public std::false_type
+  {};
+
+#ifndef DOXYGEN
+  // version for types with begin() and end()
+  template<typename T>
+  struct is_range<T,
+                  decltype(Std::declval<T>().begin()),
+                  decltype(Std::declval<T>().end())>
+    : public std::true_type
+  {};
+#endif
+
   namespace detail
   {
     ///