hermitian_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 herm_detail {
template <typename M>
struct hermitian_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; 

    hermitian_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
    }

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

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

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

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

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

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

    bool operator==(const hermitian_reference& rhs) const {
        return value == rhs.value;
    }

    bool operator!=(const hermitian_reference& rhs) const {
        return value != rhs.value;
    }

    bool operator==(const value_type& rhs) const {
        return value == rhs;
    }

    bool operator!=(const value_type& rhs) const {
        return value != rhs;
    }

    operator const_raw_reference_type&() const {
        return value;
    }

    friend std::ostream& operator<<(std::ostream& os, const hermitian_reference& ref) {
        typename M::value_type c = ref;
        return os << c;
    }
};

template <typename M>
inline typename M::value_type get_conj(const hermitian_reference<M>& ref) {
    typename M::value_type c = ref;
    using etl::get_conj;
    return get_conj(c);
}

} //end of namespace herm_detail

} //end of namespace etl