dyn_pool_derivative_expr.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/expr/base_temporary_expr.hpp"

//Get the implementations
#include "etl/impl/pooling.hpp"

namespace etl {

template <etl_expr A, etl_expr B, typename Impl>
struct dyn_pool_derivative_expr : base_temporary_expr_bin<dyn_pool_derivative_expr<A, B, Impl>, A, B> {
    using value_type  = value_t<A>;                               
    using this_type   = dyn_pool_derivative_expr<A, B, Impl>;     
    using base_type   = base_temporary_expr_bin<this_type, A, B>; 
    using left_traits = decay_traits<A>;                          

    static constexpr auto storage_order = left_traits::storage_order; 

    static constexpr bool gpu_computable = false;

    const size_t c1; 
    const size_t c2; 
    const size_t c3; 

    const size_t s1; 
    const size_t s2; 
    const size_t s3; 

    const size_t p1; 
    const size_t p2; 
    const size_t p3; 

    explicit dyn_pool_derivative_expr(A a, B b, size_t c1, size_t c2, size_t c3, size_t s1, size_t s2, size_t s3, size_t p1, size_t p2, size_t p3) :
            base_type(a, b), c1(c1), c2(c2), c3(c3), s1(s1), s2(s2), s3(s3), p1(p1), p2(p2), p3(p3) {
        //Nothing else to init
    }

    // Assignment functions

    template <etl_expr C>
    void assign_to(C&& c) const {
        inc_counter("temp:assign");

        auto& a = this->a();
        auto& b = this->b();

        Impl::apply(smart_forward(a), smart_forward(b), c, c1, c2, c3, s1, s2, s3, p1, p2, p3);
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, lhs);
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, lhs);
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, lhs);
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, lhs);
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, lhs);
    }

    friend std::ostream& operator<<(std::ostream& os, const dyn_pool_derivative_expr& expr) {
        return os << "pool_derivative(" << expr._a << ", " << expr._b << ")";
    }
};

template <typename A, typename B, typename Impl>
struct etl_traits<etl::dyn_pool_derivative_expr<A, B, Impl>> {
    using expr_t       = etl::dyn_pool_derivative_expr<A, B, Impl>; 
    using left_expr_t  = std::decay_t<A>;                           
    using right_expr_t = std::decay_t<B>;                           
    using left_traits  = etl_traits<left_expr_t>;                   
    using right_traits = etl_traits<right_expr_t>;                  
    using value_type   = value_t<A>;                                

    static constexpr bool is_etl         = true;                                          
    static constexpr bool is_transformer = false;                                         
    static constexpr bool is_view        = false;                                         
    static constexpr bool is_magic_view  = false;                                         
    static constexpr bool is_fast        = left_traits::is_fast && right_traits::is_fast; 
    static constexpr bool is_linear      = false;                                         
    static constexpr bool is_thread_safe = true;                                          
    static constexpr bool is_value       = false;                                         
    static constexpr bool is_direct      = true;                                          
    static constexpr bool is_generator   = false;                                         
    static constexpr bool is_padded      = false;                                         
    static constexpr bool is_aligned     = true;                                          
    static constexpr bool is_temporary   = true;                                          
    static constexpr bool gpu_computable = is_gpu_t<value_type> && cuda_enabled;          
    static constexpr order storage_order = left_traits::storage_order;                    

    template <vector_mode_t V>
    static constexpr bool vectorizable = true;

    template <size_t DD>
    static constexpr size_t dim() {
        return left_traits::template dim<DD>();
    }

    static size_t dim(const expr_t& e, size_t d) {
        return left_traits::dim(e._a, d);
    }

    static size_t size(const expr_t& e) {
        return left_traits::size(e._a);
    }

    static constexpr size_t size() {
        return left_traits::size();
    }

    static constexpr size_t dimensions() {
        return left_traits::dimensions();
    }

    static constexpr int complexity() noexcept {
        return -1;
    }
};

template <typename E, typename F>
dyn_pool_derivative_expr<detail::build_type<E>, F, impl::max_pool_derivative_2d> max_pool_derivative_2d(E&& input, F&& output, size_t c1, size_t c2) {
    return dyn_pool_derivative_expr<detail::build_type<E>, F, impl::max_pool_derivative_2d>{input, output, c1, c2, 0, c1, c2, 0, 0, 0, 0};
}

template <typename E, typename F>
dyn_pool_derivative_expr<detail::build_type<E>, F, impl::max_pool_derivative_2d> max_pool_derivative_2d(
        E&& input, F&& output, size_t c1, size_t c2, size_t s1, size_t s2, size_t p1 = 0, size_t p2 = 0) {
    return dyn_pool_derivative_expr<detail::build_type<E>, F, impl::max_pool_derivative_2d>{input, output, c1, c2, 0, s1, s2, 0, p1, p2, 0};
}

template <typename E, typename F>
dyn_pool_derivative_expr<detail::build_type<E>, F, impl::max_pool_derivative_3d> max_pool_derivative_3d(
    E&& input, F&& output, size_t c1, size_t c2, size_t c3) {
    return dyn_pool_derivative_expr<detail::build_type<E>, F, impl::max_pool_derivative_3d>{input, output, c1, c2, c3, c1, c2, c3, 0, 0, 0};
}

template <typename E, typename F>
dyn_pool_derivative_expr<detail::build_type<E>, F, impl::avg_pool_derivative_2d> avg_pool_derivative_2d(E&& input, F&& output, size_t c1, size_t c2) {
    return dyn_pool_derivative_expr<detail::build_type<E>, F, impl::avg_pool_derivative_2d>{input, output, c1, c2, 0, c1, c2, 0, 0, 0, 0};
}

template <typename E, typename F>
dyn_pool_derivative_expr<detail::build_type<E>, F, impl::avg_pool_derivative_2d> avg_pool_derivative_2d(
        E&& input, F&& output, size_t c1, size_t c2, size_t s1, size_t s2, size_t p1 = 0, size_t p2 = 0) {
    return dyn_pool_derivative_expr<detail::build_type<E>, F, impl::avg_pool_derivative_2d>{input, output, c1, c2, 0, s1, s2, 0, p1, p2, 0};
}

template <typename E, typename F>
dyn_pool_derivative_expr<detail::build_type<E>, F, impl::avg_pool_derivative_3d> avg_pool_derivative_3d(
        E&& input, F&& output, size_t c1, size_t c2, size_t c3) {
    return dyn_pool_derivative_expr<detail::build_type<E>, F, impl::avg_pool_derivative_3d>{input, output, c1, c2, c3, c1, c2, c3, 0, 0, 0};
}

} //end of namespace etl