transpose_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/transpose.hpp"

namespace etl {

template <typename A>
struct transpose_expr : base_temporary_expr_un<transpose_expr<A>, A> {
    using value_type = value_t<A>;                           
    using this_type  = transpose_expr<A>;                    
    using base_type  = base_temporary_expr_un<this_type, A>; 
    using sub_traits = decay_traits<A>;                      

    static constexpr auto storage_order = sub_traits::storage_order; 

    static constexpr bool gpu_computable = cublas_enabled && all_floating<A>;

    explicit transpose_expr(A a) : base_type(a) {
        //Nothing else to init
    }

    template <typename C>
    static void check([[maybe_unused]] const A& a, [[maybe_unused]] const C& c) {
        static constexpr etl::order order_lhs = decay_traits<C>::storage_order;
        static constexpr etl::order order_rhs = decay_traits<A>::storage_order;

        [[maybe_unused]] static constexpr bool rm_to_rm = order_lhs == etl::order::RowMajor && order_rhs == etl::order::RowMajor;
        [[maybe_unused]] static constexpr bool cm_to_cm = order_lhs == etl::order::ColumnMajor && order_rhs == etl::order::ColumnMajor;
        [[maybe_unused]] static constexpr bool rm_to_cm = order_lhs == etl::order::RowMajor && order_rhs == etl::order::ColumnMajor;
        [[maybe_unused]] static constexpr bool cm_to_rm = order_lhs == etl::order::ColumnMajor && order_rhs == etl::order::RowMajor;

        if constexpr (all_fast<A, C>) {
            static constexpr size_t L1 = decay_traits<C>::template dim<0>();
            static constexpr size_t L2 = decay_traits<C>::template dim<1>();
            static constexpr size_t R1 = decay_traits<A>::template dim<0>();
            static constexpr size_t R2 = decay_traits<A>::template dim<1>();

            // Case 1: RM -> RM
            static_assert(!rm_to_rm || (L1 == R2 && L2 == R1), "Invalid dimensions for transposition");

            // Case 2: CM -> CM
            static_assert(!cm_to_cm || (L1 == R2 && L2 == R1), "Invalid dimensions for transposition");

            // Case 3: RM -> CM (two possible cases)
            static_assert(!rm_to_cm || ((L1 == R2 && L2 == R1) || (L1 == R1 && L2 == R2)), "Invalid dimensions for transposition");

            // Case 4: RM -> CM (two possible cases)
            static_assert(!cm_to_rm || ((L1 == R2 && L2 == R1) || (L1 == R1 && L2 == R2)), "Invalid dimensions for transposition");
        } else {
            [[maybe_unused]] const size_t L1 = etl::dim<0>(c);
            [[maybe_unused]] const size_t L2 = etl::dim<1>(c);
            [[maybe_unused]] const size_t R1 = etl::dim<0>(a);
            [[maybe_unused]] const size_t R2 = etl::dim<1>(a);

            // Case 1: RM -> RM
            cpp_assert(!rm_to_rm || (L1 == R2 && L2 == R1), "Invalid dimensions for transposition");

            // Case 2: CM -> CM
            cpp_assert(!cm_to_cm || (L1 == R2 && L2 == R1), "Invalid dimensions for transposition");

            // Case 3: RM -> CM (two possible cases)
            cpp_assert(!rm_to_cm || ((L1 == R2 && L2 == R1) || (L1 == R1 && L2 == R2)), "Invalid dimensions for transposition");

            // Case 4: RM -> CM (two possible cases)
            cpp_assert(!cm_to_rm || ((L1 == R2 && L2 == R1) || (L1 == R1 && L2 == R2)), "Invalid dimensions for transposition");
        }
    }

    // Assignment functions

    template <etl_expr C>
    void assign_to(C&& c) const {
        if constexpr (decay_traits<C>::storage_order == storage_order) {
            inc_counter("temp:assign");

            auto& a = this->a();

            check(a, c);

            detail::transpose::apply(a, c);
        } else {
            std_assign_evaluate(*this, c);
        }
    }

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

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

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

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

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

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

template <typename A>
struct etl_traits<etl::transpose_expr<A>> {
    using expr_t     = etl::transpose_expr<A>; 
    using sub_expr_t = std::decay_t<A>;        
    using sub_traits = etl_traits<sub_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        = sub_traits::is_fast;                  
    static constexpr bool is_linear      = true;                                 
    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 = sub_traits::storage_order;            

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

    template <size_t DD>
    static constexpr size_t dim() {
        return DD == 0 ? decay_traits<A>::template dim<1>() : decay_traits<A>::template dim<0>();
    }

    static size_t dim(const expr_t& e, size_t d) {
        return d == 0 ? etl::dim<1>(e._a) : etl::dim<0>(e._a);
    }

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

    static constexpr size_t size() {
        return decay_traits<A>::size();
    }

    static constexpr size_t dimensions() {
        return 2;
    }

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

} //end of namespace etl