Array2D.h

 
#ifndef ARRAY2D_H_
#define ARRAY2D_H_
 
#include <vector>
#include "utils/mardyn_assert.h"
 
template<class T>
class Array2D: private std::vector<T> {
public:
 
    Array2D(std::size_t dim0 = 0, std::size_t dim1 = 0) :
            std::vector<T>(dim0 * dim1) {
        mardyn_assert(this->size() == dim0 * dim1);
        m_dim[0] = dim0;
        m_dim[1] = dim1;
    }
 
 
    std::size_t dim0() const {
        return m_dim[0];
    }
 
 
    std::size_t dim1() const {
        return m_dim[1];
    }
 
 
    std::size_t dim(unsigned char d) const {
        mardyn_assert(d < 3);
        return m_dim[d];
    }
 
 
    void redim(std::size_t dim0, std::size_t dim1) {
        this->resize(dim0 * dim1);
        mardyn_assert(this->size() == dim0 * dim1);
        m_dim[0] = dim0;
        m_dim[1] = dim1;
    }
 
 
    T& operator()(std::size_t i0, std::size_t i1) {
        return (*this)[indices2hash(i0, i1)];
    }
 
 
    std::size_t indices2hash(std::size_t i0, std::size_t i1) const {
        mardyn_assert(i0 < dim0());
        mardyn_assert(i1 < dim1());
 
        //return i0*m_dim[1]+i1;  // "column-order"
        return i1 * m_dim[0] + i0;  // "row-order"
    }
 
 
    void hash2indices(std::size_t h, std::size_t& i0, std::size_t& i1) const {
        mardyn_assert(h < this->size());
 
        // "column-order"
        //i1=h%m_dim[1];
        //i0=h/m_dim[1];
        // "row-order"
        i0 = h % m_dim[0];
        i1 = h / m_dim[0];
    }
 
protected:
    std::size_t m_dim[2];
};
#endif /*ARRAY2D_H_*/