---

DynamicSparseRowMatrix.h

/****************************************************************************
 *                                                                          *
 *  Program: FDDlib                                                         *
 *  Version: 1.1                                                            *
 *                                                                          *
 *  Copyright (C) 2002 - 2004 by Eric Miller and Dana Brooks                *
 *  All rights reserved.                                                    *
 *                                                                          *
 *  This software is Version 1.1 of the fddlib tomography toolbox.          *
 *  It is not to be redistributed or used for any commercial purpose        *
 *  without the prior written consent of the authors and Northeastern       *
 *  University.                                                             *
 *                                                                          *
 *  This software is provided as is, and any express or implied warranties, *
 *  including but not limited to the implied warranty of merchantability    *
 *  and the implied warranty of fitness for a particular purpose, are dis-  *
 *  claimed.  In no event shall the authors or Northeastern University be   *
 *  liable for any direct, indirect, incidental, special, exemplary, or     *
 *  consequential damages (including but not limited to procurement of      * 
 *  substitute goods or services; loss of use, data, or profits; or busi-   *
 *  ness interruption) however caused and on any theory of liability,       *
 *  whether in contract, strict liability, or tort (including negligence or *
 *  otherwise) arising in any way from the use of this software, even if    *
 *  advised of the possibility of such damage.                              *
 *                                                                          *
 *  Portions of this code benefit from ideas from Kyle Guilbert, Greg       *
 *  Boverman, Derek Uluski, David Kaeli, and Jennifer Black                 *
 *                                                                          *
 ****************************************************************************/

#ifndef _DynamicSparseRowMatrix_H_
#define _DynamicSparseRowMatrix_H_

#include <stdlib.h>
#include "SparseRowMatrix.h"
#include "error.h"

namespace FDDlib {

template <class T>
class DynamicSparseRowMatrix : public SparseRowMatrix<T>
{
private:
  SparseRowEntry<T>* setHelper(int row, int col);

public:
  DynamicSparseRowMatrix();

  DynamicSparseRowMatrix(int maxrows, int max_per_row);

  DynamicSparseRowMatrix(const DynamicSparseRowMatrix<T>& ESR);

  int set(int row, int col, T val);

  int setEntriesPerRow(int newmax);

};


template<class T>
DynamicSparseRowMatrix<T>::DynamicSparseRowMatrix() :
  SparseRowMatrix<T>()
{}

template<class T>
DynamicSparseRowMatrix<T>::DynamicSparseRowMatrix(int maxrows,int max_per_row):
  SparseRowMatrix<T>(maxrows, max_per_row)
{}

template<class T>
DynamicSparseRowMatrix<T>::DynamicSparseRowMatrix(const
  DynamicSparseRowMatrix<T>& ESR) : SparseRowMatrix<T>(ESR)
{}

template<class T>
inline int DynamicSparseRowMatrix<T>::setEntriesPerRow(int newmax)
{
  int i, j;
  const int oldmax = EntriesPerRow_;
  const int newlen = MaxRows_*newmax;
  const int arrlendiff = (newlen)-(MaxRows_*oldmax);
  int offset = 0;
  void* newaddr;

  if (newmax <= oldmax)
    return ERR_ARGS;

  // reallocate space
  newaddr = realloc(Entries_, sizeof(SparseRowEntry<T>)*newlen);

  // if realloc fails
  if (newaddr == NULL) return ERR_DATA;
  else Entries_ = (struct SparseRowEntry<T>*)newaddr;

  // copy all the entries into their new positions,
  // starting from the rightmost row chunk.
  for (i = (MaxRows_*oldmax)-1; i >= oldmax; i -= oldmax) {
    for (j = i; j > (i-oldmax); j--) {
      Entries_[j + (arrlendiff-(newmax-oldmax)) - offset] = Entries_[j];
    }
    // increase the offset. this makes sure the next row entries
    // are moved over the correct number of positions.
    offset += (newmax-oldmax);
  }

  EntriesPerRow_ = newmax;
  return SUCCESS;
}

template<class T>
inline SparseRowEntry<T>* DynamicSparseRowMatrix<T>::setHelper(int row, int col)
{
  int i;
  SparseRowEntry<T>* ep;

  ep = getRowEntry(row);
  for (i = 0; i < NumCols_[row] && ep->column != col; i++)
  {
    // if (ep->column == col)   
      // break;
    ep++;
  }
  // Removed if-break from body of loop and added && ep->column != col
  // to eliminate use of break; statement.  1/15/04 Jennifer Black

  return ep;
}

template<class T>
inline int DynamicSparseRowMatrix<T>::set(int row, int col, T val)
{
  int       i;
  SparseRowEntry<T>* ep;
  SparseRowEntry<T>* r;

  ep = setHelper(row, col);
  r = getRowEntry(row);

  // if we have reached the maximum entries per row
  if (ep - r >= EntriesPerRow_) {
    if (setEntriesPerRow(EntriesPerRow_+1)) return ERR_DATA;

    // We now have enough space to put in the new entry.
    // Since the entries are all rearranged, we need to
    // get the row entry and insertion point again.
    ep = setHelper(row, col);
    r = getRowEntry(row);

  }

  // increment column count if necessary
  if (ep - r == NumCols_[row])
    (NumCols_[row])++;

  ep->val = val;
  ep->column = col;

  return SUCCESS;

}

} // end namespace

#endif

---