hash_vector.h

Go to the documentation of this file.

// Copyright (c) 2021, Aalto University, developed by Erik Schultheis
// All rights reserved.
//
// SPDX-License-Identifier: MIT
 
#ifndef DISMEC_HASH_VECTOR_H
#define DISMEC_HASH_VECTOR_H
 
#include <memory>
#include "matrix_types.h"
 
namespace dismec
{
    class VectorHash;
 
    class HashVector {
    public:
        explicit HashVector(DenseRealVector data);
 
        [[nodiscard]] const DenseRealVector& get() const { return m_Data; }
        const DenseRealVector* operator->() const { return &m_Data; }
 
        [[nodiscard]] VectorHash hash() const;
 
        template<class Derived>
        HashVector& operator=(const Eigen::EigenBase<Derived>& expr) {
            update_id();
            m_Data = expr;
            return *this;
        }
 
        DenseRealVector& modify() {
            update_id();
            return m_Data;
        }
    private:
        void update_id();
 
        std::size_t m_UniqueID;
        DenseRealVector m_Data;
    };
 
 
    class VectorHash {
    public:
        VectorHash();
 
        bool operator==(const VectorHash& other) const {
            return m_UniqueID == other.m_UniqueID;
        }
        bool operator!=(const VectorHash& other) const {
            return !(*this == other);
        }
    private:
        VectorHash(std::size_t id) : m_UniqueID(id) {}
        std::size_t m_UniqueID;
 
        friend class HashVector;
    };
 
    // overload vector operators
    template<class T>
    auto operator+(const HashVector& vec, T&& other) {
        return vec.get() + other;
    }
 
    template<class T>
    auto operator+(T&& other, const HashVector& vec) {
        return other + vec.get() ;
    }
 
    template<class T>
    auto operator+=(T&& other, const HashVector& vec) {
        return other += vec.get() ;
    }
 
    template<class T>
    auto operator*(const HashVector& vec, T&& other) {
        return vec.get() * other;
    }
 
    template<class T>
    auto operator*(T&& other, const HashVector& vec) {
        return other * vec.get() ;
    }
 
    template<class T>
    auto operator*=(T&& other, const HashVector& vec) {
        return other *= vec.get() ;
    }
 
    class CacheHelper {
    public:
        explicit CacheHelper(Eigen::Index size) : m_Input(), m_Output(size) {}
 
        template<class F>
        const DenseRealVector& update(const HashVector& input, F&& function) {
            if(input.hash() == m_Input) {
                return m_Output;
            }
            function(input.get(), m_Output);
            m_Input = input.hash();
            return m_Output;
        }
 
        void invalidate() {
            m_Input = {};
        }
    private:
        VectorHash m_Input;
        DenseRealVector m_Output;
    };
}
#endif //DISMEC_HASH_VECTOR_H