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 "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 fast_matrix_impl final : fast_matrix_base<fast_matrix_impl<T, ST, SO, Dims...>, T, ST, SO, Dims...>,
                                inplace_assignable<fast_matrix_impl<T, ST, SO, Dims...>>,
                                expression_able<fast_matrix_impl<T, ST, SO, Dims...>>,
                                value_testable<fast_matrix_impl<T, ST, SO, Dims...>>,
                                iterable<fast_matrix_impl<T, ST, SO, Dims...>, SO == order::RowMajor>,
                                dim_testable<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>;          
    static constexpr size_t alignment    = default_intrinsic_traits<T>::alignment; 

    using this_type          = 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:

    fast_matrix_impl() noexcept : base_type() {
        // Nothing else to init
    }

    template <typename VT>
    explicit fast_matrix_impl(const VT& value) noexcept requires(std::convertible_to<VT, value_type> || std::assignable_from<T&, VT>) : base_type() {
        // Fill the matrix
        std::fill(begin(), end(), value);
    }

    fast_matrix_impl(std::initializer_list<value_type> l) : base_type() {
        cpp_assert(l.size() == size(), "Cannot copy from an initializer of different size");

        std::copy(l.begin(), l.end(), begin());
    }

    fast_matrix_impl(const storage_impl& data) : base_type(data) {
        //Nothing else to init
    }

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

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

    template <std_container Container>
    explicit fast_matrix_impl(const Container& container) requires(
            !is_complex_t<Container> && std::convertible_to<typename Container::value_type, value_type>) :
            base_type() {
        validate_assign(*this, container);
        std::copy(container.begin(), container.end(), begin());
    }

    // Assignment

    fast_matrix_impl& operator=(const fast_matrix_impl& rhs) noexcept(assert_nothrow) {
        // Avoid copy to self
        if (this != &rhs) {
            // This will handle the possible copy to GPU
            this->_gpu = rhs._gpu;

            // If necessary, perform the actual copy to CPU
            if (this->is_cpu_up_to_date()) {
                _data = rhs._data;
            }

            cpp_assert(rhs.is_cpu_up_to_date() == this->is_cpu_up_to_date(), "fast::operator= must preserve CPU status");
            cpp_assert(rhs.is_gpu_up_to_date() == this->is_gpu_up_to_date(), "fast::operator= must preserve GPU status");
        }

        return *this;
    }

    fast_matrix_impl& operator=(fast_matrix_impl&& rhs) noexcept {
        // Avoid move to self
        if (this != &rhs) {
            // This will handle the possible copy to GPU
            this->_gpu = std::move(rhs._gpu);

            // If necessary, perform the actual copy to CPU
            if (this->is_cpu_up_to_date()) {
                _data = std::move(rhs._data);
            }
        }

        return *this;
    }

    template <size_t... SDims>
    fast_matrix_impl& operator=(const fast_matrix_impl<T, ST, SO, SDims...>& rhs) noexcept {
        // Make sure the assign is valid
        validate_assign(*this, rhs);

        // Since the type is different, it is handled by the
        // evaluator which will handle all the possible cases
        rhs.assign_to(*this);

        return *this;
    }

    template <std_container Container>
    fast_matrix_impl& operator=(const Container& container) noexcept requires(std::convertible_to<typename Container::value_type, value_type>) {
        validate_assign(*this, container);
        std::copy(container.begin(), container.end(), begin());

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

        return *this;
    }

    template <etl_expr E>
    fast_matrix_impl& operator=(E&& e) requires(std::convertible_to<value_t<E>, value_type> && !std::same_as<std::decay_t<E>, this_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
                auto tmp = force_temporary_dim_only(*this);

                // Assign the expression to the temporary
                e.assign_to(tmp);

                // 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>
    fast_matrix_impl& operator=(const VT& value) noexcept requires requires (T& lhs, VT rhs) {lhs = rhs; } {
        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(fast_matrix_impl& other) {
        using std::swap;
        swap(_data, other._data);
    }

    template <typename V = default_vec>
    void store(vec_type<V> in, size_t i) noexcept {
        V::store(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::stream(memory_start() + i, in);
    }

    template <typename V = default_vec>
    vec_type<V> load(size_t i) const noexcept {
        return V::load(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 fast_matrix_impl& matrix) {
        if constexpr (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 <size_t... Dims, typename T>
fast_matrix_impl<T, std::span<T>, order::RowMajor, Dims...> fast_matrix_over(T* memory) {
    return fast_matrix_impl<T, std::span<T>, order::RowMajor, Dims...>(std::span<T>(memory, (Dims * ...)));
}

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

template <typename Stream, typename T, typename ST, order SO, size_t... Dims>
void serialize(serializer<Stream>& os, const fast_matrix_impl<T, ST, SO, Dims...>& matrix) {
    for (const auto& value : matrix) {
        os << value;
    }
}

template <typename Stream, typename T, typename ST, order SO, size_t... Dims>
void deserialize(deserializer<Stream>& os, fast_matrix_impl<T, ST, SO, Dims...>& matrix) {
    for (auto& value : matrix) {
        os >> value;
    }
}

} //end of namespace etl