SparseBitmatrix.hpp

Go to the documentation of this file.

/*
 * SparseBitmatrix.h
 *
 * Time-stamp: <05/06/01 12:40:26 lars>
 *
 * history: 2004/04/01  1.0  LST created.
 */

#ifndef __SPARSE_BITMATRIX__
#define __SPARSE_BITMATRIX__ t

#include <iostream>
using namespace std;

#include "common/debug.hpp"
// #include "LabeledSparseBitvector.hpp"
#include "SparseBitvector.hpp"

// FIXME should become template parameters
typedef unsigned int ROW_T;

class SparseBitmatrix {
 public:
  SparseBitmatrix(int numRows);
  SparseBitmatrix(int numRows, int rowCapacity);
  SparseBitmatrix(int numRows, int* rowCapacities);
  SparseBitmatrix(int numRows, int* rowCapacities, int* rowLabels);
  ~SparseBitmatrix();

  int nRows() const { return numRows; }
  void setNRows(int nRows) { 
    assert(nRows <= sizeRows);
    numRows = nRows; 
  }
  // int& rowLength(int row) { return rowLengths[row]; }
  int& rowLength(int row) const { 
    assert(row >= 0);
    assert(row < sizeRows);
    return rowLengths[row]; 
  }
  int* rowValues(int row) const { 
    assert(row >= 0);
    assert(row < sizeRows);
    return rows[row]; 
  }
  void setRowLength(int row, int length) { 
    assert(row >= 0);
    assert(row < sizeRows);
    assert(length >= 0);
    assert(length <= rowSizes[row]);
    rowLengths[row] = length; 
  }
  /*
  int& operator[] (int row, int position) { 
    assert(row >= 0);
    assert(row < numRows);
    assert(position >= 0);
    assert(position < rowSizes[row]);
    return rows[row][position]; 
  }
  */
  /*
  int element(int row, int position) {
    assert(row >= 0);
    assert(row < numRows);
    assert(position >= 0);
    assert(position < rowSizes[row]);
    return rows[row][position]; 
  }
  void setElement(int row, int position, int column) {
    assert(row >= 0);
    assert(row < numRows);
    assert(position >= 0);
    assert(position < rowSizes[row]);
    rows[row][position] = column; 
  }
  */
  void push_back(int row, int column) {
    assert(row >= 0);
    assert(row < numRows);
    assert(rowLengths[row] < rowSizes[row]);
    assert(rowLengths[row] == 0 || column > rows[row][rowLengths[row]-1]); // assert each row to be sorted in ascending order
    rows[row][rowLengths[row]++] = column;
  }

  int maxRowLength() const { return m_maxRowLength; }
  void setMaxRowLength(int maxRowLength) { this->m_maxRowLength = maxRowLength; }
  int computeMaxRowLength() { 
    m_maxRowLength = 0;
    for (int i = 0; i < numRows; i++)
      if (rowLengths[i] > m_maxRowLength)
        m_maxRowLength = rowLengths[i];
    return m_maxRowLength; 
  }

  ROW_T rowLabel(int row) const { 
    assert(row >= 0);
    assert(row < numRows);
    return rowLabels[row]; 
  }
  void setRowLabel(int row, ROW_T label) { 
    assert(row >= 0);
    assert(row < numRows);
    rowLabels[row] = label; 
  }
  ROW_T* getRowLabels() const { 
    return rowLabels; 
  }

  int capacity() const { return sizeRows; }

  int capacity(int row) const { 
    assert(row >= 0);
    assert(row < sizeRows);
    return rowSizes[row]; 
  }

  int* capacities() const { 
    return rowSizes;
  }

  SparseBitvector& getRow(int row) const {
    assert(row >= 0);
    assert(row < numRows);
#if DEBUG_LEVEL > 0
    return *(new SparseBitvector(rows[row], rowLengths[row], rowSizes[row]));
#else
    return *(new SparseBitvector(rows[row], rowLengths[row]));
#endif
  }

  /*
  void getRow(int row, SparseBitvector& vector) const {
    assert(row >= 0);
    assert(row < numRows);
#if DEBUG_LEVEL > 0
    vector.set(rows[row], rowLengths[row], rowSizes[row]);
#else
    vector.set(rows[row], rowLengths[row]);
#endif
  }
  */

  void computeEmpiricalDensity(long& numCells, long& numUsedCells) const;

  void dump() const;
  void dumpStructure() const;
  void sortRows();

  int SparseBitmatrix::filterMinimalRowLength(int minRowLength);

  int SparseBitmatrix::filterMinimalRowLength_destroyStructure(int minRowLength);

  void SparseBitmatrix::shiftRowStorage(int firstRow);  

  //#if USE_DYNAMIC_MEMORY_NODE_EXIT
  //private:
  //int rowshift;
  //#endif

private:
  int numRows;
  int** rows;
  int m_maxRowLength;
  int* rowLengths;
  ROW_T* rowLabels;

  // size (i.e., allocated memory):
  int sizeRows;
  int* rowSizes;

  

};

#endif

---