custom_fast.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 <type_traits>
#include "etl/fast_base.hpp"
#include "etl/direct_fill.hpp" //direct_fill with GPU support

namespace etl {

template <typename T, typename ST, order SO, size_t... Dims>
struct custom_fast_matrix_impl final : fast_matrix_base<custom_fast_matrix_impl<T, ST, SO, Dims...>, T, ST, SO, Dims...>,
                                       inplace_assignable<custom_fast_matrix_impl<T, ST, SO, Dims...>>,
                                       expression_able<custom_fast_matrix_impl<T, ST, SO, Dims...>>,
                                       value_testable<custom_fast_matrix_impl<T, ST, SO, Dims...>>,
                                       iterable<custom_fast_matrix_impl<T, ST, SO, Dims...>, SO == order::RowMajor>,
                                       dim_testable<custom_fast_matrix_impl<T, ST, SO, Dims...>> {
    static_assert(sizeof...(Dims) > 0, "At least one dimension must be specified");

public:
    static constexpr size_t n_dimensions = sizeof...(Dims);               
    static constexpr size_t etl_size     = (Dims * ...);                  
    static constexpr order storage_order = SO;                            
    static constexpr bool array_impl     = !matrix_detail::is_vector<ST>; 

    using this_type          = custom_fast_matrix_impl<T, ST, SO, Dims...>;     
    using base_type          = fast_matrix_base<this_type, T, ST, SO, Dims...>; 
    using iterable_base_type = iterable<this_type, SO == order::RowMajor>;      
    using value_type         = T;                                               
    using storage_impl       = ST;                                              
    using memory_type        = value_type*;                                     
    using const_memory_type  = const value_type*;                               

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

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

private:
    using base_type::_data;

public:

    explicit custom_fast_matrix_impl(memory_type memory) : base_type(storage_impl{memory, etl_size}) {
        //Nothing else to init
    }

    custom_fast_matrix_impl(const custom_fast_matrix_impl& rhs) noexcept : base_type(rhs) {
        // Nothing else to init
    }

    custom_fast_matrix_impl(custom_fast_matrix_impl&& rhs) noexcept : base_type(std::move(rhs)) {
        // Nothing else to init
    }

    // Assignment

    custom_fast_matrix_impl& operator=(const custom_fast_matrix_impl& rhs) noexcept {
        if (this != &rhs) {
            direct_copy(rhs.memory_start(), rhs.memory_end(), memory_start());
        }

        return *this;
    }

    template <size_t... SDims>
    custom_fast_matrix_impl& operator=(const custom_fast_matrix_impl<T, ST, SO, SDims...>& rhs) noexcept {
        validate_assign(*this, rhs);
        rhs.assign_to(*this);
        return *this;
    }

    custom_fast_matrix_impl& operator=(custom_fast_matrix_impl&& rhs) noexcept {
        if (this != &rhs) {
            _data = std::move(rhs._data);
        }

        return *this;
    }

    template <typename C>
    custom_fast_matrix_impl& operator=(const C& container) noexcept requires(!std::same_as<C, value_type> && std::convertible_to<value_t<C>, value_type>) {
        validate_assign(*this, container);
        std::copy(container.begin(), container.end(), begin());

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

        return *this;
    }

    template <convertible_expr<value_type> E>
    custom_fast_matrix_impl& operator=(E&& e) {
        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::fast_dyn_matrix_o<T, SO, Dims...> 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);
        }

        return *this;
    }

    template <typename VT>
    custom_fast_matrix_impl& operator=(const VT& value) noexcept requires(std::convertible_to<VT, value_type> || std::assignable_from<T&, VT>) {
        direct_fill(*this, value);

        return *this;
    }

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

    // Swap operations

    void swap(custom_fast_matrix_impl& other) {
        using std::swap;
        swap(_data, other._data);
    }

    // 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_start() + i);
    }

    template <typename V = default_vec>
    vec_type<V> loadu(size_t i) const noexcept {
        return V::loadu(memory_start() + 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, [[maybe_unused]] const custom_fast_matrix_impl& matrix) {
        if (sizeof...(Dims) == 1) {
            return os << "V[" << concat_sizes(Dims...) << "]";
        }

        return os << "M[" << concat_sizes(Dims...) << "]";
    }
};

#ifndef CPP_UTILS_ASSERT_EXCEPTION
static_assert(std::is_nothrow_default_constructible_v<fast_vector<double, 2>>, "fast_vector should be nothrow default constructible");
static_assert(std::is_nothrow_copy_constructible_v<fast_vector<double, 2>>, "fast_vector should be nothrow copy constructible");
static_assert(std::is_nothrow_move_constructible_v<fast_vector<double, 2>>, "fast_vector should be nothrow move constructible");
static_assert(std::is_nothrow_copy_assignable_v<fast_vector<double, 2>>, "fast_vector should be nothrow copy assignable");
static_assert(std::is_nothrow_move_assignable_v<fast_vector<double, 2>>, "fast_vector should be nothrow move assignable");
static_assert(std::is_nothrow_destructible_v<fast_vector<double, 2>>, "fast_vector should be nothrow destructible");
#endif

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

} //end of namespace etl