defaults.hh

Go to the documentation of this file.

// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_COMMON_SIMD_DEFAULTS_HH
#define DUNE_COMMON_SIMD_DEFAULTS_HH
 
#include <algorithm>
#include <cstddef>
#include <type_traits>
 
#include <dune/common/rangeutilities.hh>
#include <dune/common/simd/base.hh>
#include <dune/common/simd/interface.hh>
#include <dune/common/typelist.hh>
#include <dune/common/typetraits.hh>
 
namespace Dune {
  namespace Simd {
    namespace Overloads {
 
      template<class V>
      decltype(auto) lane(ADLTag<0>, std::size_t l, V v) = delete;
 
      template<class V>
      constexpr V implCast(ADLTag<0>, MetaType<V>, const V &u)
      {
        return u;
      }
 
      template<class V, class U>
      constexpr V implCast(ADLTag<0>, MetaType<V>, const U &u)
      {
        V result(Simd::Scalar<V>(0));
        for(auto l : range(Simd::lanes(u)))
          Simd::lane(l, result) = Simd::lane(l, u);
        return result;
      }
 
      template<class V, class S>
      auto broadcast(ADLTag<0>, MetaType<V>, S s)
      {
        return V(Simd::Scalar<V>(s));
      }
 
      template<class V>
      V cond(ADLTag<0>, const Mask<V> &mask,
             const V &ifTrue, const V &ifFalse) = delete;
 
      template<class V>
      auto max(ADLTag<0>, const V &v1, const V &v2)
      {
        using std::max;
        return max(v1, v2);
      }
 
      template<class V>
      auto min(ADLTag<0>, const V &v1, const V &v2)
      {
        using std::min;
        return min(v1, v2);
      }
 
      template<class Mask>
      bool anyTrue(ADLTag<0>, const Mask &mask) = delete;
 
 
      template<class Mask>
      bool allTrue(ADLTag<0>, const Mask &mask)
      {
        return !Dune::Simd::anyTrue(!mask);
      }
 
 
      template<class Mask>
      bool anyFalse(ADLTag<0>, const Mask &mask)
      {
        return Dune::Simd::anyTrue(!mask);
      }
 
 
      template<class Mask>
      bool allFalse(ADLTag<0>, const Mask &mask)
      {
        return !Dune::Simd::anyTrue(mask);
      }
 
      template<class V>
      auto max(ADLTag<0>, const V &v)
      {
        Scalar<V> m = Simd::lane(0, v);
        for(std::size_t l = 1; l < Simd::lanes(v); ++l)
          if(m < Simd::lane(l, v))
            m = Simd::lane(l, v);
        return m;
      }
 
      template<class V>
      auto min(ADLTag<0>, const V &v)
      {
        Scalar<V> m = Simd::lane(0, v);
        for(std::size_t l = 1; l < Simd::lanes(v); ++l)
          if(Simd::lane(l, v) < m)
            m = Simd::lane(l, v);
        return m;
      }
 
      template<class V>
      Mask<V> mask(ADLTag<0, std::is_same<V, Mask<V> >::value>,
                   const V &v)
      {
        return v;
      }
 
      template<class V>
      auto mask(ADLTag<0, !std::is_same<V, Mask<V> >::value>,
                const V &v)
      {
        using Copy = AutonomousValue<V>; // just in case we are handed a proxy
        return v != Copy(Scalar<Copy>(0));
      }
 
      template<class V1, class V2>
      auto maskOr(ADLTag<0>, const V1 &v1, const V2 &v2)
      {
        return Simd::mask(v1) || Simd::mask(v2);
      }
 
      template<class V1, class V2>
      auto maskAnd(ADLTag<0>, const V1 &v1, const V2 &v2)
      {
        return Simd::mask(v1) && Simd::mask(v2);
      }
 
    } // namespace Overloads
  } // namespace Simd
} // namespace Dune
 
#endif // DUNE_COMMON_SIMD_DEFAULTS_HH