symmetric_reference.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

namespace etl {

namespace sym_detail {

template <typename M>
struct symmetric_reference {
    using matrix_type              = M;                                
    using value_type               = typename matrix_type::value_type; 
    using raw_pointer_type         = value_type*;                      
    using raw_reference_type       = value_type&;                      
    using const_raw_reference_type = std::add_const_t<value_type>&;    
    using expr_t                   = M;                                

    matrix_type& matrix;   
    size_t i;              
    size_t j;              
    value_type& value;     
    value_type& sym_value; 

    symmetric_reference(matrix_type& matrix, size_t i, size_t j) : matrix(matrix), i(i), j(j), value(matrix(i, j)), sym_value(matrix(j, i)) {
        //Nothing else to init
    }

    symmetric_reference& operator=(const value_type& rhs) {
        value = rhs;
        if (i != j) {
            sym_value = rhs;
        }
        return *this;
    }

    symmetric_reference& operator+=(value_type rhs) {
        value += rhs;
        if (i != j) {
            sym_value += rhs;
        }
        return *this;
    }

    symmetric_reference& operator-=(value_type rhs) {
        value -= rhs;
        if (i != j) {
            sym_value -= rhs;
        }
        return *this;
    }

    symmetric_reference& operator*=(value_type rhs) {
        value *= rhs;
        if (i != j) {
            sym_value *= rhs;
        }
        return *this;
    }

    symmetric_reference& operator/=(value_type rhs) {
        value /= rhs;
        if (i != j) {
            sym_value /= rhs;
        }
        return *this;
    }

    symmetric_reference& operator%=(value_type rhs) {
        value %= rhs;
        if (i != j) {
            sym_value %= rhs;
        }
        return *this;
    }

    operator const_raw_reference_type&() const {
        return value;
    }
};

} //end of namespace sym_detail

} //end of namespace etl