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);

      const Data& 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(const RaggedMatrix& 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 const Data& 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