DRaggedMatrix.h

#ifndef UTIL_D_RAGGED_MATRIX_H
#define UTIL_D_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/containers/RaggedMatrix.h>
#include <util/containers/DArray.h>
#include <util/global.h>

namespace Util
{

   template <typename Data>
   class DRaggedMatrix : public RaggedMatrix<Data>
   {

      using RaggedMatrix<Data>::data_;
      using RaggedMatrix<Data>::rows_;
      using RaggedMatrix<Data>::capacity1_;
      using RaggedMatrix<Data>::capacity2_;
      using RaggedMatrix<Data>::capacity_;

   public:

      DRaggedMatrix();

      ~DRaggedMatrix();

      void allocate(const DArray<int>& rowSizes);

      bool isAllocated() const;

   };

   // Method definitions

   /*
   * Default constructor.
   */
   template <typename Data>
   DRaggedMatrix<Data>::DRaggedMatrix() :
      RaggedMatrix<Data>()
   {}
     
   /*
   * Destructor.
   */
   template <typename Data>
   DRaggedMatrix<Data>::~DRaggedMatrix()
   {
      if (data_) {
         Memory::deallocate<Data>(data_, capacity_);
      }
      if (rows_) {
         Memory::deallocate<Data*>(rows_, capacity1_);
      }
      if (capacity2_) {
         Memory::deallocate<int>(capacity2_, capacity1_);
      }
   }

   /*
   * Allocate memory and set row sizes.
   */
   template <typename Data>
   void DRaggedMatrix<Data>::allocate(const DArray<int>& rowSizes)
   {
      if (data_ != 0) 
         UTIL_THROW("Attempt to re-allocate a RaggedMatrix");

      if (rowSizes.capacity() <= 0) 
         UTIL_THROW("rowSizes.capacity() must be positive");

      // Calculate total number of elements (all rows)
      capacity_ = 0; 
      for (int i = 0; i < rowSizes.capacity(); ++i) {
         if (rowSizes[i] < 0) 
            UTIL_THROW("rowSizes must all be nonnegative");
         capacity_ += rowSizes[i];
      }

      if (capacity_ == 0) 
         UTIL_THROW("Sum of row sizes must be positive");

      // Allocate all memory
      capacity1_ = rowSizes.capacity();
      Memory::allocate<int>(capacity2_, capacity1_);
      Memory::allocate<Data*>(rows_, capacity1_);
      Memory::allocate<Data>(data_, capacity_);

      // Set row sizes and pointers to rows
      Data* ptr = data_;
      for (int i = 0; i < capacity1_; ++i) {
         capacity2_[i] = rowSizes[i];
         rows_[i] = ptr;
         ptr += rowSizes[i];
      }
      
   }

   /*
   * Return true if the DRaggedMatrix has been allocated, false otherwise.
   */
   template <class Data>
   inline bool DRaggedMatrix<Data>::isAllocated() const 
   {  return !(data_ == 0); }

}
#endif