tpl_dynMat.H

#ifndef TPL_DYNMAT_H
#define TPL_DYNMAT_H

# include <ahDry.H>
# include <tpl_dynArray.H>

namespace Aleph {

    template <typename T> 
class DynMatrix 
{
  size_t n = 0;
  size_t m = 0;

  DynArray<T> * array_ptr = NULL;

  mutable T Zero = T();

  const T & read_array_entry(const size_t i) const
  {
    const T * entry_ptr = array_ptr->test(i);

    return entry_ptr == NULL ? Zero : *entry_ptr;
  }

  T & write_array_entry(const size_t i, const T & data)
  {
    T & ref = array_ptr->touch(i) = data;

    return ref;
  }

  size_t get_index(const size_t i, const size_t j) const
  {
    return i*m + j;
  }

public:

  void set_default_initial_value(const T & value)
  {
    array_ptr->set_default_initial_value(value);
  }

  void swap(DynMatrix & mat)
  {
    std::swap(n, mat.n);
    std::swap(m, mat.m);
    std::swap(Zero, mat.Zero);
    std::swap(array_ptr, mat.array_ptr);
  }

  void set_dimension(const size_t __n, const size_t __m)
  {
    if (array_ptr != NULL) // se verifica porque puede llamarse desde el ctor
      delete array_ptr;

    n = __n;
    m = __m;
    size_t d, s, b;
    const size_t N = n*m;
    DynArray<T>::compute_sizes(N, d, s, b);

    array_ptr = new DynArray<T> (d, s, b);
    array_ptr->set_default_initial_value(Zero);
  }

  void allocate()
  {
    array_ptr->reserve(n*m);
  }

  DynMatrix(const size_t __n, const size_t __m, const T & zero = T())
    : n(__n), m(__m), array_ptr(NULL), Zero(zero)
  {
    set_dimension(n, m);
  }

  ~DynMatrix()
  {
    if (array_ptr)
      delete array_ptr;
  }

  DynMatrix(const DynMatrix<T> & mat) 
    : DynMatrix(mat.n, mat.m, mat.Zero)
  {
    *array_ptr = *mat.array_ptr;
  }

  DynMatrix(DynMatrix<T> && mat)
  {
    swap(mat);
  }

  DynMatrix<T> & operator = (const DynMatrix<T> & mat) 
  {
    if (this == &mat)
      return *this;

    n = mat.n;
    m = mat.m;
    array_ptr->copy_array_exactly(*this, mat);

    return *this;
  }

  DynMatrix<T> operator = (DynMatrix<T> && mat) 
  {
    swap(mat);
    return *this;
  }

  bool operator == (const DynMatrix<T> & mat) const
  {
    const size_t N = n*m;
    for (int i = 0; i < N; ++i)
      if (read_array_entry(i) != mat.read_array_entry(i))
        return false;

    return true;
  }

  const size_t & rows() const { return n; }

  const size_t & cols() const { return m; }

  const T & read(const size_t i, const size_t j) const
  {
    I(i < n and j < m);

    return read_array_entry(get_index(i, j));
  }

  T & write(const size_t i, const size_t j, const T & data)
  {
    I(i < n and j < m);

    return write_array_entry(get_index(i, j), data);
  }

  T & access(const size_t i, const size_t j)
  {
    return array_ptr->access(get_index(i, j));
  }

  T & operator () (const size_t i, const size_t j)
  {
    return access(i, j);
  }

  T & access(const size_t i, const size_t j) const
  {
    return array_ptr->access(get_index(i, j));
  }

  T & operator () (const size_t i, const size_t j) const
  {
    return access(i, j);
  }

  template <class Operation>
  bool traverse(Operation & operation) const
  {
    return array_ptr->traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation & operation) 
  {
    return array_ptr->traverse(operation); 
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) const
  {
    return traverse<Operation>(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) 
  {
    return traverse<Operation>(operation);
  }

  Functional_Methods(T);
};

} // end namespace Aleph

#endif // TPL_DYNMAT_H