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

namespace etl {

namespace detail {

template <typename V>
V compute(size_t n, size_t i, size_t j) {
    if (n == 1) {
        return 1;
    } else if (n == 2) {
        return i == 0 && j == 0 ? 1 : i == 0 && j == 1 ? 3 : i == 1 && j == 0 ? 4 : 2;
    } else {
        //Siamese method
        return n * (((i + 1) + (j + 1) - 1 + n / 2) % n) + (((i + 1) + 2 * (j + 1) - 2) % n) + 1;
    }
}

} //end of namespace detail

//Note: Matrix of even order > 2 are only pseudo-magic
//TODO Add algorithm for even order

template <typename V>
struct magic_view {
    using value_type = V; 

    const size_t n; 

    static constexpr bool gpu_computable = false;

    explicit magic_view(size_t n) : n(n) {}

    value_type operator[](size_t i) {
        return detail::compute<value_type>(n, i / n, i % n);
    }

    value_type operator[](size_t i) const {
        return detail::compute<value_type>(n, i / n, i % n);
    }

    value_type read_flat(size_t i) const {
        return detail::compute<value_type>(n, i / n, i % n);
    }

    value_type operator()(size_t i, size_t j) {
        return detail::compute<value_type>(n, i, j);
    }

    value_type operator()(size_t i, size_t j) const {
        return detail::compute<value_type>(n, i, j);
    }

    template <typename E>
    constexpr bool alias(const E& rhs) const noexcept {
        return (void)rhs, false;
    }

    // Internals

    template <typename Visitor>
    void visit([[maybe_unused]] Visitor&& visitor) const {}

    void ensure_cpu_up_to_date() const {
        // Nothing to ensure
    }

    void ensure_gpu_up_to_date() const {
        // Nothing to ensure
    }
};

template <typename V, size_t N>
struct fast_magic_view {
    using value_type = V; 

    static constexpr bool gpu_computable = false;

    value_type operator[](size_t i) {
        return detail::compute<value_type>(N, i / N, i % N);
    }

    value_type operator[](size_t i) const {
        return detail::compute<value_type>(N, i / N, i % N);
    }

    value_type read_flat(size_t i) const {
        return detail::compute<value_type>(N, i / N, i % N);
    }

    value_type operator()(size_t i, size_t j) {
        return detail::compute<value_type>(N, i, j);
    }

    value_type operator()(size_t i, size_t j) const {
        return detail::compute<value_type>(N, i, j);
    }

    template <typename E>
    constexpr bool alias(const E& rhs) const noexcept {
        return (void)rhs, false;
    }

    // Internals

    template <typename Visitor>
    void visit([[maybe_unused]] Visitor&& visitor) const {}

    void ensure_cpu_up_to_date() const {
        // Nothing to ensure
    }

    void ensure_gpu_up_to_date() const {
        // Nothing to ensure
    }
};

template <typename V>
struct etl_traits<etl::magic_view<V>> {
    using expr_t     = etl::magic_view<V>; 
    using value_type = V;                  

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

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

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

    static size_t dim(const expr_t& v, [[maybe_unused]] size_t d) {
        return v.n;
    }

    static constexpr size_t dimensions() {
        return 2;
    }

    static constexpr int complexity() noexcept {
        return 16;
    }
};

template <size_t N, typename V>
struct etl_traits<etl::fast_magic_view<V, N>> {
    using expr_t     = etl::fast_magic_view<V, N>; 
    using value_type = V;                          

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

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

    static constexpr size_t size() {
        return N * N;
    }

    static constexpr size_t size(const expr_t& v) {
        return (void)v, N * N;
    }

    template <size_t D>
    static constexpr size_t dim() {
        return N;
    }

    static constexpr size_t dim(const expr_t& e, size_t d) {
        return (void)e, (void)d, N;
    }

    static constexpr size_t dimensions() {
        return 2;
    }

    static constexpr int complexity() noexcept {
        return 16;
    }
};

} //end of namespace etl