min.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

#include "etl/impl/egblas/min.hpp"

namespace etl {

template <typename LT, typename RT>
struct min_binary_op {
    static constexpr bool linear      = true; 
    static constexpr bool thread_safe = true; 
    static constexpr bool desc_func   = true; 

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

    template <typename L, typename R>
    static constexpr bool gpu_computable = (all_single_precision<L, R> && impl::egblas::has_smin3) || (all_double_precision<L, R> && impl::egblas::has_dmin3)
                                           || (all_complex_single_precision<L, R> && impl::egblas::has_cmin3)
                                           || (all_complex_double_precision<L, R> && impl::egblas::has_zmin3);

    static constexpr int complexity() {
        return 1;
    }

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

    static constexpr LT apply(const LT& x, const RT& value) noexcept {
        if (x < value) {
            return x;
        } else {
            return value;
        }
    }

    template <typename V = default_vec>
    static vec_type<V> load(const vec_type<V>& lhs, const vec_type<V>& rhs) noexcept {
        return V::min(lhs, rhs);
    }

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

        constexpr size_t inca = gpu_inc<decltype(x)>;
        constexpr size_t incb = gpu_inc<decltype(y)>;

        auto t3 = force_temporary_gpu_dim_only(t1);

        LT alpha(1);
        impl::egblas::min(etl::size(yy), alpha, t1.gpu_memory(), inca, t2.gpu_memory(), incb, t3.gpu_memory(), 1);

        return t3;
    }

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

        constexpr size_t inca = gpu_inc<decltype(x)>;
        constexpr size_t incb = gpu_inc<decltype(y)>;

        LT alpha(1);
        impl::egblas::min(etl::size(yy), alpha, t1.gpu_memory(), inca, t2.gpu_memory(), incb, yy.gpu_memory(), 1);

        yy.validate_gpu();
        yy.invalidate_cpu();

        return yy;
    }

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

} //end of namespace etl