base_matrix.h

Go to the documentation of this file.

#ifndef BASE_MATRIX_H
#define BASE_MATRIX_H
 
#include <iostream>
#include <mutex>
#include <cassert>
 
namespace hamilt
{
template <typename T>
class BaseMatrix
{
  public:
    // Constructor of class BaseMatrix
    BaseMatrix(const int& nrow_, const int& ncol_, T* data_existed = nullptr);
    // copy constructor
    BaseMatrix(const BaseMatrix<T>& matrix);
    // move constructor
    BaseMatrix(BaseMatrix<T>&& matrix);
    // Destructor of class BaseMatrix
    ~BaseMatrix();
 
    void allocate(T* data_array = nullptr, bool if_zero = false);
 
    void set_zero();
 
    void add_array(T* array);
 
    void add_element(int mu, int nu, const T& value)
    {
        #ifdef __DEBUG
        assert(this->value_begin != nullptr);
        #endif
            int index = mu * this->ncol_local + nu;
            value_begin[index] += value;
    };
 
    // for inside matrix
    T& get_value(const size_t& i_row, const size_t& j_col) const
    {
        #ifdef __DEBUG
        assert(this->value_begin != nullptr);
        #endif
            int index = i_row * this->ncol_local + j_col;
            return value_begin[index];
    };
 
    T* get_pointer() const { return value_begin; };
 
    // operator= for copy assignment
    BaseMatrix& operator=(const BaseMatrix& other);
 
    // operator= for move assignment
    BaseMatrix& operator=(BaseMatrix&& other) noexcept;
 
    size_t get_memory_size() const;
 
    int get_col_size() const {return ncol_local;};
    int get_row_size() const {return nrow_local;};
    void set_size(const int& col_size_in, const int& row_size_in);
 
    void add_array_ts(T* array)
    {
        std::lock_guard<std::mutex> lock(mtx);
        const int size = nrow_local * ncol_local;
        for (int i = 0; i < size; ++i)
        {
            value_begin[i] += array[i];
        }
    }
 
    // Cross-type variant: cast each element of `array` to T before accumulating.
    // Selected by overload resolution only when TSrc != T (the non-template
    // overload is preferred when types match).
    template <typename TSrc>
    void add_array_ts(const TSrc* array)
    {
        std::lock_guard<std::mutex> lock(mtx);
        const int size = nrow_local * ncol_local;
        for (int i = 0; i < size; ++i)
        {
            value_begin[i] += static_cast<T>(array[i]);
        }
    }
 
  private:
    bool allocated = false;
 
    // pointer for accessing data
    // two ways to arrange data:
    // 1. allocate data itself
    // 2. only access data but be arranged by RealSparseHamiltonian
    T* value_begin = nullptr;
 
    // int current_multiple = 0;
 
    // for thread safe
    mutable std::mutex mtx;
    // number of rows and columns
    int nrow_local = 0;
    int ncol_local = 0;
};
 
} // namespace hamilt
 
#endif