simd/interface.hh

Go to the documentation of this file.

// SPDX-FileCopyrightInfo: Copyright © 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_INTERFACE_HH
#define DUNE_COMMON_SIMD_INTERFACE_HH

#include <cassert>
#include <cstddef>
#include <type_traits>
#include <utility>

#include <dune/common/simd/base.hh>
#include <dune/common/typelist.hh>

namespace Dune {


  namespace Simd {


    template<class V>
    using Scalar = typename Overloads::ScalarType<std::decay_t<V> >::type;


    template<class S, class V>
    using Rebind =
      typename Overloads::RebindType<std::decay_t<S>, std::decay_t<V>>::type;



    template<class V>
    using Mask = Rebind<bool, V>;



    template<class V>
    constexpr std::size_t lanes()
    {
      return Overloads::LaneCount<std::decay_t<V>>::value;
    }


    template<class V>
    decltype(auto) lane(std::size_t l, V &&v)
    {
      assert(l < lanes<V>());
      return lane(Overloads::ADLTag<7>{}, l, std::forward<V>(v));
    }


    template<class V, class U>
    constexpr V implCast(U &&u)
    {
      static_assert(std::is_same<Scalar<V>, Scalar<U> >::value,
                    "Scalar types must match exactly in implCast");
      static_assert(lanes<V>() == lanes<U>(),
                    "Number of lanes must match in implCast");
      return implCast(Overloads::ADLTag<7>{}, MetaType<std::decay_t<V> >{},
                      std::forward<U>(u));
    }


    template<class V, class S>
    constexpr V broadcast(S s)
    {
      return broadcast(Overloads::ADLTag<7>{}, MetaType<std::decay_t<V> >{},
                       std::move(s));
    }


    template<class M, class V>
    V cond(M &&mask, const V &ifTrue, const V &ifFalse)
    {
      return cond(Overloads::ADLTag<7>{},
                  implCast<Mask<V> >(std::forward<M>(mask)), ifTrue, ifFalse);
    }


    template<class V>
    V cond(bool mask, const V &ifTrue, const V &ifFalse)
    {
      return mask ? ifTrue : ifFalse;
    }


    template<class V>
    auto max(const V &v1, const V &v2)
    {
      return max(Overloads::ADLTag<7>{}, v1, v2);
    }


    template<class V>
    auto min(const V &v1, const V &v2)
    {
      return min(Overloads::ADLTag<7>{}, v1, v2);
    }


    template<class Mask>
    bool anyTrue(const Mask &mask)
    {
      return anyTrue(Overloads::ADLTag<7>{}, mask);
    }


    template<class Mask>
    bool allTrue(const Mask &mask)
    {
      return allTrue(Overloads::ADLTag<7>{}, mask);
    }


    template<class Mask>
    bool anyFalse(const Mask &mask)
    {
      return anyFalse(Overloads::ADLTag<7>{}, mask);
    }


    template<class Mask>
    bool allFalse(const Mask &mask)
    {
      return allFalse(Overloads::ADLTag<7>{}, mask);
    }


    template<class V>
    Scalar<V> max(const V &v)
    {
      return max(Overloads::ADLTag<7>{}, v);
    }


    template<class V>
    Scalar<V> min(const V &v)
    {
      return min(Overloads::ADLTag<7>{}, v);
    }


    template<class V>
    auto mask(const V &v)
    {
      return mask(Overloads::ADLTag<7>{}, v);
    }


    template<class V1, class V2>
    auto maskOr(const V1 &v1, const V2 &v2)
    {
      return maskOr(Overloads::ADLTag<7>{}, v1, v2);
    }


    template<class V1, class V2>
    auto maskAnd(const V1 &v1, const V2 &v2)
    {
      return maskAnd(Overloads::ADLTag<7>{}, v1, v2);
    }



    template<class V>
    std::size_t lanes(const V &)
    {
      return lanes<V>();
    }



  } // namespace Simd
} // namespace Dune

#endif // DUNE_COMMON_SIMD_INTERFACE_HH