relu.hpp

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================
#pragma once

namespace etl {

template <typename T>
struct relu_unary_op {
    static constexpr bool linear      = true; 
    static constexpr bool thread_safe = true; 

    template <vector_mode_t V>
    static constexpr bool vectorizable = !is_complex_t<T>;

    template <typename E>
    static constexpr bool gpu_computable = is_floating<E>&& cudnn_enabled;

    static constexpr int complexity() {
        return 1;
    }

    template <typename V = default_vec>
    using vec_type = typename V::template vec_type<T>;

    static T apply(const T& x) {
        return std::max(x, T(0));
    }

    template <typename V = default_vec>
    static vec_type<V> load(const vec_type<V>& x) noexcept {
        return V::max(x, V::set(T(0)));
    }

    template <typename X, typename Y>
    static auto gpu_compute_hint(const X& x, Y& y) noexcept {
        decltype(auto) t1 = smart_gpu_compute_hint(x, y);

        auto t2 = force_temporary_gpu_dim_only(t1);
        impl::cudnn::relu(t1, t2);
        return t2;
    }
    template <typename X, typename Y>
    static Y& gpu_compute(const X& x, Y& y) noexcept {
        decltype(auto) t1 = select_smart_gpu_compute(x, y);

        impl::cudnn::relu(t1, y);

        return y;
    }

    static std::string desc() noexcept {
        return "relu";
    }
};

} //end of namespace etl