uni_upper.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/uni_upper_exception.hpp" // The exception
#include "etl/adapters/uni_upper_reference.hpp" // The reference proxy

namespace etl {

template <adaptable Matrix>
struct uni_upper_matrix final : adapter<Matrix>, iterable<const uni_upper_matrix<Matrix>> {
    using matrix_t  = Matrix;                   
    using expr_t    = matrix_t;                 
    using this_type = uni_upper_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:
    uni_upper_matrix() noexcept : base_type() {
        // Fill the diagonal
        for (size_t i = 0; i < etl::dim<0>(value); ++i) {
            value(i, i) = value_type(1);
        }
    }

    explicit uni_upper_matrix(size_t dim) noexcept : base_type(dim) {
        // Fill the diagonal
        for (size_t i = 0; i < etl::dim<0>(value); ++i) {
            value(i, i) = value_type(1);
        }
    }

    uni_upper_matrix(const uni_upper_matrix& rhs) = default;

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

    uni_upper_matrix(uni_upper_matrix&& rhs) noexcept = default;

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

    template <convertible_expr<value_type> E>
    uni_upper_matrix& operator=(E&& e) noexcept(false) {
        // Make sure the other matrix is uni upper triangular
        if (!is_uni_upper_triangular(e)) {
            throw uni_upper_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>
    uni_upper_matrix& operator+=(const R & rhs) {
        // Make sure the other matrix is uni upper triangular
        if (!is_uni_upper_triangular(rhs)) {
            throw uni_upper_exception();
        }

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

    template <etl_expr R>
    uni_upper_matrix& operator-=(const R & rhs) {
        // Make sure the other matrix is uni upper triangular
        if (!is_uni_upper_triangular(rhs)) {
            throw uni_upper_exception();
        }

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

    template <typename R>
    uni_upper_matrix& operator*=(const R & rhs) {
        // Make sure the other matrix is uni upper triangular
        if (!is_uni_upper_triangular(rhs)) {
            throw uni_upper_exception();
        }

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

    template <etl_expr R>
    uni_upper_matrix& operator>>=(const R & rhs) {
        // Make sure the other matrix is uni upper triangular
        if (!is_uni_upper_triangular(rhs)) {
            throw uni_upper_exception();
        }

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

    template <etl_expr R>
    uni_upper_matrix& operator/=(const R & rhs) {
        // Make sure the other matrix is uni upper triangular
        if (!is_uni_upper_triangular(rhs)) {
            throw uni_upper_exception();
        }

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

    uni_upper_detail::uni_upper_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<uni_upper_matrix<Matrix>> : wrapper_traits<uni_upper_matrix<Matrix>> {};

} //end of namespace etl