RaggedMatrix.h

#ifndef UTIL_RAGGED_MATRIX_H
#define UTIL_RAGGED_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 RaggedMatrix
   {
 
   public:
 
      // Protected default constructor, to prohibit direct instantiation.
 
      // Private copy constructor, to prohibit copy construction.

      virtual ~RaggedMatrix();

      int capacity1();

      int capacity2(int i);

      Data const & operator() (int i, int j) const;

      Data& operator() (int i, int j);
 
   protected:

      Data*  data_;

      Data**  rows_;

      int*  capacity2_;

      int  capacity1_;

      int  capacity_;

      RaggedMatrix();
 
   private:

      RaggedMatrix(RaggedMatrix const & other);
 
   }; 
 
   // Method definitions

   template <typename Data>
   inline RaggedMatrix<Data>::RaggedMatrix()
    : data_(0),
      rows_(0),
      capacity2_(0),
      capacity1_(0),
      capacity_(0)
   {}
 
   /*
   * Destructor.
   */
   template <typename Data>
   RaggedMatrix<Data>::~RaggedMatrix()
   {}
 
   /*
   * Get number of rows.
   */
   template <typename Data>
   inline int RaggedMatrix<Data>::capacity1()
   { return capacity1_; }
 
   /*
   * Get number of columns in row i.
   */
   template <typename Data>
   inline int RaggedMatrix<Data>::capacity2(int i)
   {  return capacity2_[i]; }
 
   /*
   * Return element (i,j) of matrix by const reference.
   */
   template <typename Data>
   inline 
   Data const & RaggedMatrix<Data>::operator() (int i, int j) const
   {
      assert(data_ != 0);
      assert(i >= 0);
      assert(i < capacity1_);
      assert(j >= 0);
      assert(j < capacity2_[i]);
      return *(rows_[i] + j);
   }
 
   /*
   * Return element (i,j) of matrix by reference.
   */
   template <typename Data>
   inline Data& RaggedMatrix<Data>::operator() (int i, int j)
   {
      assert(data_ != 0);
      assert(i >= 0);
      assert(i < capacity1_);
      assert(j >= 0);
      assert(j < capacity2_[i]);
      return *(rows_[i] + j);
   }
 
}
#endif