sub_matrix_4d.hpp

Go to the documentation of this file.

//=======================================================================
// 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

#ifdef ETL_CUDA
#include "etl/impl/cublas/cuda.hpp"
#endif

namespace etl {

template <etl_expr T, bool Aligned>
struct sub_matrix_4d final : iterable<sub_matrix_4d<T, Aligned>, false>,
                             assignable<sub_matrix_4d<T, Aligned>, value_t<T>>,
                             value_testable<sub_matrix_4d<T, Aligned>>,
                             inplace_assignable<sub_matrix_4d<T, Aligned>> {
    using this_type            = sub_matrix_4d<T, Aligned>;                                            
    using iterable_base_type   = iterable<this_type, false>;                                           
    using assignable_base_type = assignable<this_type, value_t<T>>;                                    
    using sub_type             = T;                                                                    
    using value_type           = value_t<sub_type>;                                                    
    using memory_type          = memory_t<sub_type>;                                                   
    using const_memory_type    = const_memory_t<sub_type>;                                             
    using return_type          = return_helper<sub_type, decltype(std::declval<sub_type>()[0])>;       
    using const_return_type    = const_return_helper<sub_type, decltype(std::declval<sub_type>()[0])>; 
    using iterator             = etl::iterator<this_type>;                                             
    using const_iterator       = etl::iterator<const this_type>;                                       

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

    using assignable_base_type::operator=;
    using iterable_base_type::begin;
    using iterable_base_type::end;

private:
    sub_type sub_expr;   
    const size_t base_i; 
    const size_t base_j; 
    const size_t base_k; 
    const size_t base_l; 
    const size_t m;      
    const size_t n;      
    const size_t o;      
    const size_t p;      

    friend struct etl_traits<sub_matrix_4d>;

    static constexpr order storage_order = decay_traits<sub_type>::storage_order; 

public:
    sub_matrix_4d(sub_type sub_expr, size_t i, size_t j, size_t k, size_t l, size_t m, size_t n, size_t o, size_t p)
            : sub_expr(sub_expr), base_i(i), base_j(j), base_k(k), base_l(l), m(m), n(n), o(o), p(p) {}

    const_return_type operator[](size_t f) const {
        cpp_assert(f < m * n * o * p, "Invalid index inside sub_matrix_4d");

        if constexpr (storage_order == order::RowMajor) {
            // Extract 4D indices from flat inside the view
            auto my_i = f / (n * o * p);
            auto t1   = f % (n * o * p);
            auto my_j = t1 / (o * p);
            auto t2   = t1 % (o * p);
            auto my_k = t2 / p;
            auto my_l = t2 % p;

            // Let the sub view compute the index
            return sub_expr(base_i + my_i, base_j + my_j, base_k + my_k, base_l + my_l);
        } else {
            // Extract 4D indices from flat inside the view
            auto my_l = f / (m * n * o);
            auto t1   = f % (m * n * o);
            auto my_k = t1 / (m * n);
            auto t2   = t1 % (m * n);
            auto my_j = t2 / m;
            auto my_i = t2 % m;

            // Let the sub view compute the index
            return sub_expr(base_i + my_i, base_j + my_j, base_k + my_k, base_l + my_l);
        }
    }

    return_type operator[](size_t f) {
        cpp_assert(f < m * n * o * p, "Invalid index inside sub_matrix_4d");

        if constexpr (storage_order == order::RowMajor) {
            // Extract 4D indices from flat inside the view
            auto my_i = f / (n * o * p);
            auto t1   = f % (n * o * p);
            auto my_j = t1 / (o * p);
            auto t2   = t1 % (o * p);
            auto my_k = t2 / p;
            auto my_l = t2 % p;

            // Let the sub view compute the index
            return sub_expr(base_i + my_i, base_j + my_j, base_k + my_k, base_l + my_l);
        } else {
            // Extract 4D indices from flat inside the view
            auto my_l = f / (m * n * o);
            auto t1   = f % (m * n * o);
            auto my_k = t1 / (m * n);
            auto t2   = t1 % (m * n);
            auto my_j = t2 / m;
            auto my_i = t2 % m;

            // Let the sub view compute the index
            return sub_expr(base_i + my_i, base_j + my_j, base_k + my_k, base_l + my_l);
        }
    }

    value_type read_flat(size_t f) const noexcept(assert_nothrow) {
        cpp_assert(f < m * n * o * p, "Invalid index inside sub_matrix_4d");

        if constexpr (storage_order == order::RowMajor) {
            // Extract 4D indices from flat inside the view
            auto my_i = f / (n * o * p);
            auto t1   = f % (n * o * p);
            auto my_j = t1 / (o * p);
            auto t2   = t1 % (o * p);
            auto my_k = t2 / p;
            auto my_l = t2 % p;

            // Let the sub view compute the index
            return sub_expr(base_i + my_i, base_j + my_j, base_k + my_k, base_l + my_l);
        } else {
            // Extract 4D indices from flat inside the view
            auto my_l = f / (m * n * o);
            auto t1   = f % (m * n * o);
            auto my_k = t1 / (m * n);
            auto t2   = t1 % (m * n);
            auto my_j = t2 / m;
            auto my_i = t2 % m;

            // Let the sub view compute the index
            return sub_expr(base_i + my_i, base_j + my_j, base_k + my_k, base_l + my_l);
        }
    }

    ETL_STRONG_INLINE(const_return_type) operator()(size_t i, size_t j, size_t k, size_t l) const {
        cpp_assert(i < m, "Invalid 4d index inside sub_matrix_4d");
        cpp_assert(j < n, "Invalid 4d index inside sub_matrix_4d");
        cpp_assert(k < o, "Invalid 4d index inside sub_matrix_4d");
        cpp_assert(l < p, "Invalid 4d index inside sub_matrix_4d");

        return sub_expr(base_i + i, base_j + j, base_k + k, base_l + l);
    }

    ETL_STRONG_INLINE(return_type) operator()(size_t i, size_t j, size_t k, size_t l) {
        cpp_assert(i < m, "Invalid 4d index inside sub_matrix_4d");
        cpp_assert(j < n, "Invalid 4d index inside sub_matrix_4d");
        cpp_assert(k < o, "Invalid 4d index inside sub_matrix_4d");
        cpp_assert(l < p, "Invalid 4d index inside sub_matrix_4d");

        return sub_expr(base_i + i, base_j + j, base_k + k, base_l + l);
    }

    auto operator()(size_t x) const {
        return sub(*this, x);
    }

    template <typename E>
    bool alias(const E& rhs) const noexcept {
        return sub_expr.alias(rhs);
    }

    size_t& unsafe_dimension_access(size_t x) {
        return sub_expr.unsafe_dimension_access(x);
    }

    // Assignment functions

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

    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));
    }

    // Internals

    void ensure_cpu_up_to_date() const {
        // The sub value must be ensured
        sub_expr.ensure_cpu_up_to_date();
    }

    void ensure_gpu_up_to_date() const {
        // The sub value must be ensured
        sub_expr.ensure_gpu_up_to_date();
    }

    void visit(detail::evaluator_visitor& visitor) const {
        sub_expr.visit(visitor);
    }

    friend std::ostream& operator<<(std::ostream& os, const sub_matrix_4d& v) {
        return os << "sub(" << v.sub_expr << ", " << v.base_i << ", " << v.base_j << ", " << v.base_k << ", " << v.base_l << ", " << v.m << ", " << v.n << ", "
                  << v.o << ", " << v.p << ")";
    }
};

template <typename T, bool Aligned>
struct etl_traits<etl::sub_matrix_4d<T, Aligned>> {
    using expr_t     = etl::sub_matrix_4d<T, Aligned>;  
    using sub_expr_t = std::decay_t<T>;                 
    using sub_traits = etl_traits<sub_expr_t>;          
    using value_type = typename sub_traits::value_type; 

    static constexpr bool is_etl         = true;                       
    static constexpr bool is_transformer = false;                      
    static constexpr bool is_view        = true;                       
    static constexpr bool is_magic_view  = false;                      
    static constexpr bool is_fast        = false;                      
    static constexpr bool is_linear      = sub_traits::is_linear;      
    static constexpr bool is_thread_safe = sub_traits::is_thread_safe; 
    static constexpr bool is_value       = false;                      
    static constexpr bool is_direct      = false;                      
    static constexpr bool is_generator   = false;                      
    static constexpr bool is_padded      = false;                      
    static constexpr bool is_aligned     = false;                      
    static constexpr bool is_temporary   = sub_traits::is_temporary;   
    static constexpr bool gpu_computable = false;                      
    static constexpr order storage_order = sub_traits::storage_order;  

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

    static size_t size(const expr_t& v) noexcept {
        return v.m * v.n * v.o * v.p;
    }

    static size_t dim(const expr_t& v, size_t d) noexcept {
        if (d == 0) {
            return v.m;
        } else if (d == 1) {
            return v.n;
        } else if (d == 2) {
            return v.o;
        } else {
            return v.p;
        }
    }

    static constexpr size_t dimensions() noexcept {
        return 4;
    }

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

} //end of namespace etl