diagonal.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/adapters/adapter.hpp"            // The adapter base class
#include "etl/adapters/diagonal_exception.hpp" // The diagonal exception
#include "etl/adapters/diagonal_reference.hpp" // The reference proxy

namespace etl {

template <adaptable Matrix>
struct diagonal_matrix final : adapter<Matrix>, iterable<const diagonal_matrix<Matrix>> {
    using matrix_t  = Matrix;                  
    using expr_t    = matrix_t;                
    using this_type = diagonal_matrix<Matrix>; 

    static constexpr size_t n_dimensions = etl_traits<matrix_t>::dimensions();  
    static constexpr order storage_order = etl_traits<matrix_t>::storage_order; 
    static constexpr size_t alignment    = matrix_t::alignment;                 

    using value_type        = value_t<matrix_t>; 
    using memory_type       = value_type*;       
    using const_memory_type = const value_type*; 

    using iterator       = typename matrix_t::const_iterator; 
    using const_iterator = typename matrix_t::const_iterator; 

    using base_type = adapter<Matrix>; 

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

    using base_type::value;

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

    explicit diagonal_matrix(value_type value) noexcept : base_type(value) {
        //Nothing else to init
    }

    explicit diagonal_matrix(size_t dim) noexcept : base_type(dim) {
        //Nothing else to init
    }

    diagonal_matrix(const diagonal_matrix& rhs) = default;

    diagonal_matrix& operator=(const diagonal_matrix& rhs) = default;

    diagonal_matrix(diagonal_matrix&& rhs) noexcept = default;

    diagonal_matrix& operator=(diagonal_matrix&& rhs) noexcept = default;

    template <convertible_expr<value_type> E>
    diagonal_matrix& operator=(E&& e) noexcept(false) {
        // Make sure the other matrix is diagonal
        if (!is_diagonal(e)) {
            throw diagonal_exception();
        }

        // Perform the real assign

        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
                this_type tmp(*this);

                // 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 <etl_expr R>
    diagonal_matrix& operator+=(const R& rhs) {
        // Make sure the other matrix is diagonal
        if (!is_diagonal(rhs)) {
            throw diagonal_exception();
        }

        validate_expression(*this, rhs);
        rhs.assign_add_to(*this);
        return *this;
    }

    template <etl_expr R>
    diagonal_matrix& operator-=(const R& rhs) {
        // Make sure the other matrix is diagonal
        if (!is_diagonal(rhs)) {
            throw diagonal_exception();
        }

        validate_expression(*this, rhs);
        rhs.assign_sub_to(*this);
        return *this;
    }

    diagonal_matrix& operator*=(const value_type& rhs) noexcept {
        etl::scalar<value_type>(rhs).assign_mul_to(*this);
        return *this;
    }

    template <etl_expr R>
    diagonal_matrix& operator*=(const R& rhs) {
        // Make sure the other matrix is diagonal
        if (!is_diagonal(rhs)) {
            throw diagonal_exception();
        }

        validate_expression(*this, rhs);
        rhs.assign_mul_to(*this);
        return *this;
    }

    diagonal_matrix& operator>>=(const value_type& rhs) noexcept {
        etl::scalar<value_type>(rhs).assign_mul_to(*this);
        return *this;
    }

    template <etl_expr R>
    diagonal_matrix& operator>>=(const R& rhs) {
        // Make sure the other matrix is diagonal
        if (!is_diagonal(rhs)) {
            throw diagonal_exception();
        }

        validate_expression(*this, rhs);
        rhs.assign_mul_to(*this);
        return *this;
    }

    diagonal_matrix& operator/=(const value_type& rhs) noexcept {
        etl::scalar<value_type>(rhs).assign_div_to(*this);
        return *this;
    }

    template <etl_expr R>
    diagonal_matrix& operator/=(const R& rhs) {
        // Make sure the other matrix is diagonal
        if (!is_diagonal(rhs)) {
            throw diagonal_exception();
        }

        validate_expression(*this, rhs);
        rhs.assign_div_to(*this);
        return *this;
    }

    diagonal_matrix& operator%=(const value_type& rhs) noexcept {
        etl::scalar<value_type>(rhs).assign_mod_to(*this);
        return *this;
    }

    template <etl_expr R>
    diagonal_matrix& operator%=(const R& rhs) {
        // Make sure the other matrix is diagonal
        if (!is_diagonal(rhs)) {
            throw diagonal_exception();
        }

        validate_expression(*this, rhs);
        rhs.assign_mod_to(*this);
        return *this;
    }

    diagonal_detail::diagonal_reference<matrix_t> operator()(size_t i, size_t j) noexcept {
        return {value, i, j};
    }

    using base_type::operator();
};

template <typename Matrix>
struct etl_traits<diagonal_matrix<Matrix>> : wrapper_traits<diagonal_matrix<Matrix>> {};

} //end of namespace etl