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

#include <concepts>
#include "etl/dyn_base.hpp"    //The base class and utilities
#include "etl/direct_fill.hpp" //direct_fill with GPU support

namespace etl {

template <typename T, order SO, size_t D>
struct custom_dyn_matrix_impl final : dense_dyn_base<custom_dyn_matrix_impl<T, SO, D>, T, SO, D>,
                                      inplace_assignable<custom_dyn_matrix_impl<T, SO, D>>,
                                      expression_able<custom_dyn_matrix_impl<T, SO, D>>,
                                      value_testable<custom_dyn_matrix_impl<T, SO, D>>,
                                      iterable<custom_dyn_matrix_impl<T, SO, D>, SO == order::RowMajor>,
                                      dim_testable<custom_dyn_matrix_impl<T, SO, D>> {
    static constexpr size_t n_dimensions = D;  
    static constexpr order storage_order = SO; 
    static constexpr size_t alignment    = 1;  

    using this_type              = custom_dyn_matrix_impl<T, SO, D>;                           
    using iterable_base_type     = iterable<this_type, SO == order::RowMajor>;                 
    using base_type              = dense_dyn_base<custom_dyn_matrix_impl<T, SO, D>, T, SO, D>; 
    using value_type             = T;                                                          
    using dimension_storage_impl = std::array<size_t, n_dimensions>;                           
    using memory_type            = value_type*;                                                
    using const_memory_type      = const value_type*;                                          

    using iterator       = std::conditional_t<SO == order::RowMajor, value_type*, etl::iterator<this_type>>;             
    using const_iterator = std::conditional_t<SO == order::RowMajor, const value_type*, etl::iterator<const this_type>>; 

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

private:
    using base_type::_dimensions;
    using base_type::_memory;
    using base_type::_size;

    using base_type::check_invariants;

public:
    using base_type::dim;
    using base_type::memory_end;
    using base_type::memory_start;
    using iterable_base_type::begin;
    using iterable_base_type::end;

    // Construction

    custom_dyn_matrix_impl(const custom_dyn_matrix_impl& rhs) noexcept : base_type(rhs) {
        _memory = rhs._memory;
    }

    custom_dyn_matrix_impl(custom_dyn_matrix_impl&& rhs) noexcept : base_type(std::move(rhs)) {
        _memory     = rhs._memory;
        rhs._memory = nullptr;
    }

    template <typename... S>
    explicit custom_dyn_matrix_impl(value_type* memory, S... sizes) noexcept requires (sizeof...(S) == D) : base_type(util::size(sizes...), {{static_cast<size_t>(sizes)...}}) {
        _memory = memory;
        //Nothing else to init
    }

    custom_dyn_matrix_impl& operator=(const custom_dyn_matrix_impl& rhs) noexcept {
        if (this != &rhs) {
            _size       = rhs._size;
            _dimensions = rhs._dimensions;
            _memory     = rhs._memory;
        }

        check_invariants();

        return *this;
    }

    custom_dyn_matrix_impl& operator=(custom_dyn_matrix_impl&& rhs) noexcept {
        if (this != &rhs) {
            _size       = rhs._size;
            _dimensions = std::move(rhs._dimensions);
            _memory     = rhs._memory;

            rhs._size   = 0;
            rhs._memory = nullptr;
        }

        check_invariants();

        return *this;
    }

    template <etl_expr E>
    custom_dyn_matrix_impl& operator=(E&& e) noexcept requires(!std::same_as<std::decay_t<E>, custom_dyn_matrix_impl<T, SO, D>> && std::convertible_to<value_t<E>, value_type>) {
        validate_assign(*this, e);

        // Avoid aliasing issues
        if constexpr (!decay_traits<E>::is_linear) {
            if (e.alias(*this)) {
                // Create a temporary to hold the result
                etl::dyn_matrix_o<T, SO> tmp;

                // Assign the expression to the temporary
                tmp = e;

                // Assign the temporary to this matrix
                *this = tmp;
            } else {
                e.assign_to(*this);
            }
        } else {
            // Direct assignment of the expression into this matrix
            e.assign_to(*this);
        }

        check_invariants();

        return *this;
    }

    template <std_container Container>
    custom_dyn_matrix_impl& operator=(const Container& vec) requires(std::convertible_to<typename Container::value_type, value_type>) {
        validate_assign(*this, vec);

        std::copy(vec.begin(), vec.end(), begin());

        this->validate_cpu();
        this->invalidate_gpu();

        check_invariants();

        return *this;
    }

    custom_dyn_matrix_impl& operator=(const value_type& value) noexcept {
        direct_fill(*this, value);

        check_invariants();

        return *this;
    }

    ~custom_dyn_matrix_impl() noexcept {
        // Nothing to do
    }

    template <typename Y>
    auto& gpu_compute_hint([[maybe_unused]] Y& y) {
        this->ensure_gpu_up_to_date();
        return *this;
    }

    template <typename Y>
    const auto& gpu_compute_hint([[maybe_unused]] Y& y) const {
        this->ensure_gpu_up_to_date();
        return *this;
    }

    void swap(custom_dyn_matrix_impl& other) {
        using std::swap;
        swap(_size, other._size);
        swap(_dimensions, other._dimensions);
        swap(_memory, other._memory);

        //TODO swap is likely screwing up GPU memory!

        check_invariants();
    }

    // Accessors

    template <typename V = default_vec>
    void store(vec_type<V> in, size_t i) noexcept {
        V::storeu(memory_start() + i, in);
    }

    template <typename V = default_vec>
    void storeu(vec_type<V> in, size_t i) noexcept {
        V::storeu(memory_start() + i, in);
    }

    template <typename V = default_vec>
    void stream(vec_type<V> in, size_t i) noexcept {
        V::storeu(memory_start() + i, in);
    }

    template <typename V = default_vec>
    vec_type<V> load(size_t i) const noexcept {
        return V::loadu(_memory + i);
    }

    template <typename V = default_vec>
    vec_type<V> loadu(size_t i) const noexcept {
        return V::loadu(_memory + i);
    }

    // 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([[maybe_unused]] const detail::evaluator_visitor& visitor) const {}

    friend std::ostream& operator<<(std::ostream& os, const custom_dyn_matrix_impl& mat) {
        if (D == 1) {
            return os << "CV[" << mat.size() << "]";
        }

        os << "CM[" << mat.dim(0);

        for (size_t i = 1; i < D; ++i) {
            os << "," << mat.dim(i);
        }

        return os << "]";
    }
};

static_assert(std::is_nothrow_move_constructible_v<dyn_vector<double>>, "dyn_vector should be nothrow move constructible");
static_assert(std::is_nothrow_move_assignable_v<dyn_vector<double>>, "dyn_vector should be nothrow move assignable");
static_assert(std::is_nothrow_destructible_v<dyn_vector<double>>, "dyn_vector should be nothrow destructible");

template <typename T, order SO, size_t D>
void swap(custom_dyn_matrix_impl<T, SO, D>& lhs, custom_dyn_matrix_impl<T, SO, D>& rhs) {
    lhs.swap(rhs);
}

} //end of namespace etl