Matrix.h

#ifndef UTIL_MATRIX_H
#define UTIL_MATRIX_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/global.h>
 
namespace Util
{
 
   template <typename Data>
   class Matrix
   {
 
   public:
 
      // Protected default constructor, to prohibit direct instantiation.
 
      // Private copy constructor, to prohibit copy construction.
 
      virtual ~Matrix();
 
      int capacity1() const;
 
      int capacity2() const;
 
      Data const & operator() (int i, int j) const;
 
      Data& operator() (int i, int j);
 
      Data* cArray();
 
      Data const * cArray() const;
 
   protected:
 
      Data*  data_;
 
      int  capacity1_;
 
      int  capacity2_;
 
      Matrix();
 
   private:
 
      Matrix(Matrix<Data> const & other);
 
      Matrix<Data>& operator = (Matrix<Data> const & other);
 
   };
 
   // Method definitions
 
   template <typename Data>
   inline Matrix<Data>::Matrix()
    : data_(0),
      capacity1_(0),
      capacity2_(0)
   {}
 
   /*
   * Destructor.
   */
   template <typename Data>
   Matrix<Data>::~Matrix()
   {}
 
   /*
   * Get the number of rows.
   */
   template <typename Data>
   inline int Matrix<Data>::capacity1() const
   {  return capacity1_; }
 
   /*
   * Get the number of columns.
   */
   template <typename Data>
   inline int Matrix<Data>::capacity2() const
   {  return capacity2_; }
 
   /*
   * Return element (i,j) of matrix by const reference.
   */
   template <typename Data>
   inline Data const & Matrix<Data>::operator() (int i, int j) const
   {
      assert(data_ != 0);
      assert(i >= 0);
      assert(i < capacity1_);
      assert(j >= 0);
      assert(j < capacity2_);
      return *(data_ + i*capacity2_ + j);
   }
 
   /*
   * Return element (i,j) of matrix by reference.
   */
   template <typename Data>
   inline Data& Matrix<Data>::operator() (int i, int j)
   {
      assert(data_ != 0);
      assert(i >= 0);
      assert(i < capacity1_);
      assert(j >= 0);
      assert(j < capacity2_);
      return *(data_ + i*capacity2_ + j);
   }
 
   /*
   * Get a pointer to the underlying one-dimensional C array.
   */
   template <typename Data>
   inline Data* Matrix<Data>::cArray()
   {  return data_; }
 
   /*
   * Get a pointer to const to the underlying one-dimensional C array.
   */
   template <typename Data>
   inline Data const * Matrix<Data>::cArray() const
   {  return data_; }
 
}
#endif