strictly_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/strictly_upper_exception.hpp" // The upper exception
#include "etl/adapters/strictly_upper_reference.hpp" // The reference proxy

namespace etl {

template <adaptable Matrix>
struct strictly_upper_matrix final : adapter<Matrix>, iterable<const strictly_upper_matrix<Matrix>> {
    using matrix_t  = Matrix;                        
    using expr_t    = matrix_t;                      
    using this_type = strictly_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:
    strictly_upper_matrix() noexcept : base_type() {
        //Nothing else to init
    }

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

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

    strictly_upper_matrix(const strictly_upper_matrix& rhs) = default;

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

    strictly_upper_matrix(strictly_upper_matrix&& rhs) noexcept = default;

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

    template<convertible_expr<value_type> E>
    strictly_upper_matrix& operator=(E&& e) noexcept(false) {
        // Make sure the other matrix is strictly upper triangular
        if (!is_strictly_upper_triangular(e)) {
            throw strictly_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>
    strictly_upper_matrix& operator+=(const R & rhs) {
        // Make sure the other matrix is strictly upper triangular
        if (!is_strictly_upper_triangular(rhs)) {
            throw strictly_upper_exception();
        }

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

    template <etl_expr R>
    strictly_upper_matrix& operator-=(const R & rhs) {
        // Make sure the other matrix is strictly upper triangular
        if (!is_strictly_upper_triangular(rhs)) {
            throw strictly_upper_exception();
        }

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

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

    template <etl_expr R>
    strictly_upper_matrix& operator*=(const R & rhs) {
        // Make sure the other matrix is strictly upper triangular
        if (!is_strictly_upper_triangular(rhs)) {
            throw strictly_upper_exception();
        }

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

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

    template <etl_expr R>
    strictly_upper_matrix& operator>>=(const R & rhs) {
        // Make sure the other matrix is strictly upper triangular
        if (!is_strictly_upper_triangular(rhs)) {
            throw strictly_upper_exception();
        }

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

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

    template <etl_expr R>
    strictly_upper_matrix& operator/=(const R & rhs) {
        // Make sure the other matrix is strictly upper triangular
        if (!is_strictly_upper_triangular(rhs)) {
            throw strictly_upper_exception();
        }

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

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

    template <etl_expr R>
    strictly_upper_matrix& operator%=(const R & rhs) {
        // Make sure the other matrix is strictly upper triangular
        if (!is_strictly_upper_triangular(rhs)) {
            throw strictly_upper_exception();
        }

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

    strictly_upper_detail::strictly_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<strictly_upper_matrix<Matrix>> : wrapper_traits<strictly_upper_matrix<Matrix>> {};

} //end of namespace etl