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

namespace etl {

template <typename T, size_t D>
struct dim_view {
    static_assert(D == 1 || D == 2, "Invalid dimension");

    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, 0))>;       
    using const_return_type = const_return_helper<sub_type, decltype(std::declval<sub_type>()(0, 0))>; 

private:
    T sub;          
    const size_t i; 

    friend struct etl_traits<dim_view>;

public:
    dim_view(sub_type sub, size_t i) : sub(sub), i(i) {}

    const_return_type operator[](size_t j) const {
        if (D == 1) {
            return sub(i, j);
        } else { //D == 2
            return sub(j, i);
        }
    }

    return_type operator[](size_t j) {
        if (D == 1) {
            return sub(i, j);
        } else { //D == 2
            return sub(j, i);
        }
    }

    value_type read_flat(size_t j) const noexcept {
        if (D == 1) {
            return sub(i, j);
        } else { //D == 2
            return sub(j, i);
        }
    }

    const_return_type operator()(size_t j) const {
        if (D == 1) {
            return sub(i, j);
        } else { //D == 2
            return sub(j, i);
        }
    }

    return_type operator()(size_t j) {
        if (D == 1) {
            return sub(i, j);
        } else { //D == 2
            return sub(j, i);
        }
    }

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

    memory_type memory_start() noexcept requires(etl_dma<T> && D == 1) {
        return sub.memory_start() + i * subsize(sub);
    }

    const_memory_type memory_start() const noexcept requires(etl_dma<T> && D == 1){
        return sub.memory_start() + i * subsize(sub);
    }

    memory_type memory_end() noexcept requires(etl_dma<T> && D == 1){
        return sub.memory_start() + (i + 1) * subsize(sub);
    }

    const_memory_type memory_end() const noexcept requires(etl_dma<T> && D == 1){
        return sub.memory_start() + (i + 1) * subsize(sub);
    }

    // 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 visit(detail::evaluator_visitor& visitor) const {
        sub.visit(visitor);
    }

    void ensure_cpu_up_to_date() const {
        // Need to ensure sub value
        sub.ensure_cpu_up_to_date();
    }

    void ensure_gpu_up_to_date() const {
        // Need to ensure both LHS and RHS
        sub.ensure_gpu_up_to_date();
    }

    friend std::ostream& operator<<(std::ostream& os, const dim_view& v) {
        return os << "dim[" << D << "](" << v.sub << ", " << v.i << ")";
    }
};

template <typename T, size_t D>
struct etl_traits<etl::dim_view<T, D>> {
    using expr_t     = etl::dim_view<T, D>;                         
    using sub_expr_t = std::decay_t<T>;                             
    using value_type = typename etl_traits<sub_expr_t>::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        = etl_traits<sub_expr_t>::is_fast;             
    static constexpr bool is_linear      = false;                                       
    static constexpr bool is_thread_safe = etl_traits<sub_expr_t>::is_thread_safe;      
    static constexpr bool is_value       = false;                                       
    static constexpr bool is_direct      = etl_traits<sub_expr_t>::is_direct && D == 1; 
    static constexpr bool is_generator   = false;                                       
    static constexpr bool is_padded      = false;                                       
    static constexpr bool is_aligned     = false;                                       
    static constexpr bool is_temporary   = etl_traits<sub_expr_t>::is_temporary;        
    static constexpr bool gpu_computable = false;                                       
    static constexpr order storage_order = etl_traits<sub_expr_t>::storage_order;       

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

    static size_t size(const expr_t& v) {
        if (D == 1) {
            return etl_traits<sub_expr_t>::dim(v.sub, 1);
        } else {
            return etl_traits<sub_expr_t>::dim(v.sub, 0);
        }
    }

    static size_t dim(const expr_t& v, [[maybe_unused]] size_t d) {
        cpp_assert(d == 0, "Invalid dimension");

        return size(v);
    }

    static constexpr size_t size() {
        return D == 1 ? etl_traits<sub_expr_t>::template dim<1>() : etl_traits<sub_expr_t>::template dim<0>();
    }

    template <size_t D2>
    static constexpr size_t dim() requires(D2 == 0) {
        return size();
    }

    static constexpr size_t dimensions() {
        return 1;
    }

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

} //end of namespace etl