elementwise_functions.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/core/compiler_attributes.hpp>
 
#include <type_traits>
#include <utility>
 
namespace uni20::linalg
{
 
template <class Value> struct constant
{
    [[no_unique_address]] Value value;
 
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()() const -> Value { return value; }
};
 
template <class Value> constant(Value) -> constant<std::decay_t<Value>>;
 
struct negate
{
    template <class Value>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Value value) const noexcept(noexcept(-value))
        -> decltype(-value)
    {
      return -value;
    }
};
 
struct square
{
    template <class Value>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Value value) const noexcept(noexcept(value * value))
        -> decltype(value * value)
    {
      return value * value;
    }
};
 
struct reciprocal
{
    template <class Value>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Value value) const noexcept(noexcept(Value{1} / value))
        -> decltype(Value{1} / value)
    {
      return Value{1} / value;
    }
};
 
template <class Factor> struct scale
{
    Factor factor;
 
    template <class Value>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Value value) const noexcept(noexcept(factor * value))
        -> decltype(factor * value)
    {
      return factor * value;
    }
};
 
template <class Factor> scale(Factor) -> scale<std::decay_t<Factor>>;
 
template <class Factor> struct add_scaled
{
    Factor factor;
 
    template <class Output, class Input>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Output output, Input input) const
        noexcept(noexcept(output + factor * input)) -> decltype(output + factor * input)
    {
      return output + factor * input;
    }
};
 
template <class Factor> add_scaled(Factor) -> add_scaled<std::decay_t<Factor>>;
 
struct add
{
    template <class Left, class Right>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Left left, Right right) const
        noexcept(noexcept(left + right)) -> decltype(left + right)
    {
      return left + right;
    }
};
 
struct subtract
{
    template <class Left, class Right>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Left left, Right right) const
        noexcept(noexcept(left - right)) -> decltype(left - right)
    {
      return left - right;
    }
};
 
struct multiply
{
    template <class Left, class Right>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Left left, Right right) const
        noexcept(noexcept(left * right)) -> decltype(left * right)
    {
      return left * right;
    }
};
 
struct divide
{
    template <class Left, class Right>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(Left left, Right right) const
        noexcept(noexcept(left / right)) -> decltype(left / right)
    {
      return left / right;
    }
};
 
} // namespace uni20::linalg