datatable.h

Go to the documentation of this file.

 
#ifndef DATATABLE_H
#define DATATABLE_H
 
#include "output.h"
template <class T> class DataTable {
  
private:
  unsigned int _length;
  unsigned int _groups;
  unsigned int _classes;
  unsigned int **_cumulClassSizes;
  unsigned int *_cumulGroupSizes;
  
  unsigned int **_sizes;
  
  T* _table;
  
  void store_sizes (unsigned int nbgroups, unsigned int nbclasses, unsigned int** classSizes) {
    
    if (_sizes != NULL) {
      for(unsigned int i = 0; i < nbgroups; ++i) delete [] _sizes[i];
      delete [] _sizes;
    }
    
    _sizes = new unsigned int * [nbgroups];
    
    for(unsigned int i = 0; i < nbgroups; ++i) {
      _sizes[i] = new unsigned int [nbclasses];
      for(unsigned int j = 0; j < nbclasses; ++j)
        _sizes[i][j] = classSizes[i][j];
    }
  }
  
  bool sizeChange (unsigned int nbgroups, unsigned int nbclasses, unsigned int** classSizes) {
    bool status = 0;
    if( nbgroups != _groups || nbclasses != _classes ) return true;
    else {
      for (unsigned int i = 0; i < _groups; i++)
        for (unsigned int j = 0; j < _classes; j++)
          status |= _sizes[i][j] != classSizes[i][j];
    }
    return status;
  }
  
public:
  DataTable() : _length(0), _groups(0), _classes(0), _cumulClassSizes(0), _cumulGroupSizes(0), _sizes(0), _table(0) { }
  DataTable(unsigned int nbgroups, unsigned int nbclasses, unsigned int** classSizes) :
  _length(0), _groups(0), _classes(0), _cumulClassSizes(0), _cumulGroupSizes(0), _table(0) 
  {     allocate(nbgroups, nbclasses, classSizes); }
  
  ~DataTable() {free();}
  
  inline void allocate (unsigned int nbgroups, unsigned int nbclasses, unsigned int** classSizes) { 
    //#ifdef _DEBUG_
    //    message("DataTable::allocate:\n");
    //#endif
 
    free();
    
    store_sizes(nbgroups, nbclasses, classSizes);
    
    _groups = nbgroups;
    _classes = nbclasses;
    _length = 0;
    
    _cumulClassSizes = new unsigned int*[_groups];
 
    for(unsigned int i = 0; i < _groups; i++){
      _cumulClassSizes[i] = new unsigned int [_classes];
      _cumulClassSizes[i][0] = 0;
      for(unsigned int j = 1; j < _classes; ++j)
        _cumulClassSizes[i][j] = _cumulClassSizes[i][j-1] + classSizes[i][j-1];
    }
    
    _cumulGroupSizes = new unsigned int[_groups];
    
    _cumulGroupSizes[0] = 0; 
    for(unsigned int i = 1; i < _groups; i++){
      _cumulGroupSizes[i] = _cumulGroupSizes[i-1];
      for(unsigned int j = 0; j < _classes; ++j) {
        _cumulGroupSizes[i] += classSizes[(i-1)][j];//total size of the previous group
        _length += classSizes[i][j];//aggregate to compute total length
      }
    }
    //add the sizes of first group classes to have the total length of the table
    for(unsigned int j = 0; j < _classes; ++j)
      _length += classSizes[0][j];
    
    _table = new T[_length];
    //#ifdef _DEBUG_
//        cout<<"DataTable::allocate:_table="<<_table<<endl;
    //#endif
  }
  
  inline void update(unsigned int nbgroups, unsigned int nbclasses, unsigned int** classSizes) {
    //#ifdef _DEBUG_
    //    message("DataTable::update:\n");
    //#endif
    if( nbgroups != _groups || nbclasses != _classes )
      
      allocate(nbgroups, nbclasses, classSizes); //free() is called in allocate
    
    else if ( sizeChange(nbgroups, nbclasses, classSizes) ) {
      
      store_sizes(nbgroups, nbclasses, classSizes);
      
      for(unsigned int i = 0; i < _groups; i++){
        for(unsigned int j = 1; j < _classes; ++j)
          _cumulClassSizes[i][j] = _cumulClassSizes[i][j-1] + classSizes[i][j-1];
      }
      _length = 0;
      _cumulGroupSizes[0] = 0; 
      for(unsigned int i = 1; i < _groups; i++){
        _cumulGroupSizes[i] = _cumulGroupSizes[i-1];
        for(unsigned int j = 0; j < _classes; ++j) {
          _cumulGroupSizes[i] += classSizes[(i-1)][j];
          _length += classSizes[i][j];
        }
      }
      
      for(unsigned int j = 0; j < _classes; ++j)
        _length += classSizes[0][j];
      
      if(_table != NULL) delete [] _table;
      
      _table = new T[_length];
    }
  }
  void free ( ) {
//    cout << "\ncalling DataTable::free()\n";
//    cout <<  "    pointer state: table="<<_table<<" cumulGroupSizes="<<_cumulGroupSizes
//         <<"\n    cumulClassSizes="<<_cumulClassSizes<<" sizes="<<_sizes
//        <<endl;
 
    if(_table != NULL) delete [] _table;
    
    if(_cumulGroupSizes != NULL) delete [] _cumulGroupSizes;
//    cout << "    delete _cumulClassSizes\n";
    if(_cumulClassSizes != NULL){
      for(unsigned int i = 0; i < _groups; ++i) {
//        cout << "     "<<i<<":"<<_cumulClassSizes[i]<<endl;
        delete [] _cumulClassSizes[i];}
      delete [] _cumulClassSizes;
    }
//    cout << "    delete _sizes\n";
    if(_sizes != NULL){
      for(unsigned int i = 0; i < _groups; ++i) delete [] _sizes[i];
      delete [] _sizes;
    }
    
    _table = NULL;
    _cumulGroupSizes = NULL;
    _cumulClassSizes = NULL;
    _sizes = NULL;
    _length = 0;
//    cout << "DataTable::free() done\n";
}
  inline unsigned int length ( ) {return _length;}
  inline T* getTable ( ) {return _table;}
  inline T* getGroup (unsigned int group) {return &_table[ _cumulGroupSizes[group] ];}
  inline T* getClassWithinGroup (unsigned int group, unsigned int Class) {
    return &_table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] ];}
  inline T  get (unsigned int group, unsigned int Class, unsigned int elmnt) {
    return _table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] + elmnt ];
  } 
  inline void set (unsigned int group, unsigned int Class, unsigned int elmnt, T val) {
    _table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] + elmnt ] = val;
  }
  inline void increment (unsigned int group, unsigned int Class, unsigned int elmnt) {
    ++_table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] + elmnt ];
  }
  inline void plus (unsigned int group, unsigned int Class, unsigned int elmnt, T val) {
    _table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] + elmnt ] += val;
  }
  inline void minus (unsigned int group, unsigned int Class, unsigned int elmnt, T val) {
    _table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] + elmnt ] -= val;
  }
  inline void multiply (unsigned int group, unsigned int Class, unsigned int elmnt, T val) {
    _table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] + elmnt ] *= val;
  }
  inline void divide (unsigned int group, unsigned int Class, unsigned int elmnt, T val) {
    _table[ _cumulGroupSizes[group] + _cumulClassSizes[group][Class] + elmnt ] /= val;
  }
  inline void init (T val) {for(unsigned int i = 0; i < _length; ++i) _table[i] = val;} 
  
  unsigned int getNumGroups () {return _groups;}
  unsigned int getNumClasses () {return _classes;}
  unsigned int size (unsigned int i, unsigned int j) {return _sizes[i][j];}
  
  void show_up ()
  {
    message("DataTable: got %i groups of %i classes; total length is %i.\n", _groups, _classes, _length);
  }
};
 
#endif //DATATABLE_H