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