containers.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          containers.h  -  description
                             -------------------
    begin                : Fri Feb 20 2004
    copyright            : (C) 2004 by Christian Stimming
    email                : stimming@tuhh.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef _SIMTH_CONTAINERS_H
#define _SIMTH_CONTAINERS_H


#include <string>
#include <iostream>

#include <simthetic/misc.h>
#include <simthetic/exceptions.h>
#include <simthetic/checkedvector.h>
#include <simthetic/array.h>
#include <simthetic/phbib.h>

namespace simth
{



template<class T>
class checkedVector2d : public checkedVector< checkedVector<T> >
{
  public:
    checkedVector2d(size_t cols,size_t rows);
    void resize(size_t newCols, size_t newRows);
};


template<class T>
checkedVector2d<T>::checkedVector2d(size_t cols,size_t rows)
    : simth::checkedVector< checkedVector<T> >(cols)
{
  //this->resize(cols);
  for(size_t i=0;i< cols;++i) {
    (*this)[i].resize(rows);
  }
}





template<class T>
class vector2d : public std::vector< std::vector<T> >
{
  public:
    vector2d(size_t cols,size_t rows);
    //resize(size_t newCols, size_t newRows = -1);
    T get(size_t col, size_t row) const;
    void set(size_t col, size_t row,const T& newVal);
};


template<class T>
vector2d<T>::vector2d(size_t cols,size_t rows)
    : std::vector<std::vector<T> >(cols)
{
  //this->resize(cols);
  for(size_t i=0;i< cols;++i) {
    (*this)[i].resize(rows);
  }
}



template<class T>
inline T vector2d<T>::get(size_t col, size_t row) const
  {
#if DEBUG==1
    if(col >= this->size()) {
      throw std::out_of_range("vector2d::at(size_t col, size_t row) : col == "
                              +i2string(col)+" > " + i2string(this->size()) +" (row =="+i2string(row)+")");
    }
    if(row >= ((*this)[0]).size()) {
      throw std::out_of_range("vector2d::at(size_t col, size_t row) : (col == "
                              +i2string(col)+") row =="+i2string(row));
    }
#endif
    return (*this)[col][row];
  }


template<class T>
void vector2d<T>::set(size_t col, size_t row,const T& newVal)
{
#if DEBUG==1
  if(col >= this->size()) {
    throw std::out_of_range("vector2d::set(size_t col, size_t row, size_t newVal) : col == "
                            +i2string(col)+" > " + i2string(this->size()) +" (row =="+i2string(row)+")");
  }
  if(row >= ((*this)[0]).size()) {
    throw std::out_of_range("vector2d::set(size_t col, size_t row, size_t newVal) : (col == "
                            +i2string(col)+") row =="+i2string(row));
  }
#endif
  (*this)[col][row] = newVal;
}



class intVector2d : public std::vector<std::vector<int> >
{
  public:
    intVector2d(size_t cols,size_t rows);
    int get(size_t col, size_t row) const;
    void set(size_t col, size_t row, int newVal);
};



class boolVector2d : public std::vector< std::vector<bool> >
{
  public:
    boolVector2d(size_t cols,size_t rows);
    bool get(size_t col, size_t row) const;
    void set(size_t col, size_t row, bool bitVal);
};


class intVector3d : public std::vector< std::vector< std::vector<int> > >
{
  public:
    intVector3d(unsigned int cols, unsigned int rows, unsigned int planes);
    int get(unsigned int col, unsigned int row, unsigned int plane) const;
    void set(unsigned int col, unsigned int row, unsigned int plane,
               int newVal);
};


// /////////////////////////////////////////////////////////
// simth::Array2d
// /////////////////////////////////////////////////////////

template<class T> class Array2d
{
    typedef Array<T> row_type;
    // Size of each row (i.e. number of columns)
    size_t d2;
    // As it turned out with some profiling, a vector<T> is even
    // better than a valarray<T> here.
    std::vector< row_type > array2dPtr;

  public:
    Array2d(): d2(0)
    , array2dPtr(0) {}
    Array2d(size_t dim1, size_t dim2);
    Array2d(size_t dim1, size_t dim2, const T& Value);
    Array2d(const Array2d<T>& a);
    ~Array2d() {}
    Array2d<T>& operator=(const Array2d<T>& a);
    Array<T>& operator[](size_t pos);
    const Array<T>& operator[](size_t pos) const;
    size_t dim1() const {return array2dPtr.size();}
    size_t dim2() const {return d2;}
    size_t size() const {return d2*array2dPtr.size();}
    void resize(size_t dim1, size_t dim2, const T& val = T());
};


template<class T>
inline Array2d<T>::Array2d(size_t dim1, size_t dim2)
    : d2(dim2)
    , array2dPtr(dim1, row_type(dim2)) // other way round than for valarray
{}

template<class T>
inline Array2d<T>::Array2d(size_t dim1, size_t dim2, const T& value)
    : d2(dim2)
    , array2dPtr(dim1, row_type(value, dim2)) // other way round than for valarray
{}

template<class T>
inline Array2d<T>::Array2d(const Array2d<T>& a)
    : d2(a.d2)
    , array2dPtr(a.array2dPtr)
{}

template<class T>
inline Array2d<T>& Array2d<T>::operator=(const Array2d& a)
{
  d2 = a.d2;
  array2dPtr.operator=(a.array2dPtr);
  return *this;
}

template<class T>
inline void Array2d<T>::resize(size_t sDim1, size_t sDim2, const T& val)
{
  if (d2 != sDim2) {
    d2 = sDim2;
    // Resize each existing row into new row size
    for (size_t i = 0; i < array2dPtr.size(); i++){
      array2dPtr[i].resize(sDim2, val);
    }
  }
  // Resize number of rows into new array size
  array2dPtr.resize(sDim1, row_type(val, sDim2) );
}


template<class T>
inline Array<T>& Array2d<T>::operator[](size_t pos)
{
  if(DEBUG) {
    if(pos >= dim1()) {
      throw std::out_of_range("inline Array2d::operator[](size_t pos)const : pos == "+
                              simth::i2string(pos)+" this.size() == "+
                              simth::i2string(dim1()));
    }
  }
  return array2dPtr[pos];
}

template<class T>
inline const Array<T>& Array2d<T>::operator[](size_t pos) const
{
  if(DEBUG) {
    if(pos >= dim1()) {
      throw std::out_of_range("inline Array2d::operator[](size_t pos)const : pos == "+
                              simth::i2string(pos)+" this.dim1() == "+
                              simth::i2string(dim1()));
    }
  }
  return array2dPtr[pos];
}

// ////////////////////////////////////////////////////////////

template<class T>
void twoDim2oneDim(const Array2d<T>& arr, Array<T>* vec, bool fortranlike = false)
{
  if(DEBUG) {
    if(vec == NULL) {
      throw std::runtime_error("void twoDim2oneDim(const Array2d<T>& arr, Array<T>* vec) : vec == NULL");
    }
  }


  size_t currPos = 0;
  size_t xSize = arr.dim1();
  size_t ySize = arr.dim2();

  if(fortranlike) {  //store array by columns:
    for(size_t x = 0; x < xSize; ++x) {
      for(size_t y = 0; y < ySize; ++y) {
        (*vec)[currPos]=arr[x][y];
        ++currPos;
      }
    }
  }
  else {  //store array by rows:
    for(size_t y = 0; y < ySize; ++y) {
      for(size_t x = 0; x < xSize; ++x) {
        (*vec)[currPos]=arr[x][y];
        ++currPos;
      }
    }
  }
}


template<class T>
void oneDim2twoDim(const Array<T>& vec, size_t xSize, size_t ySize, Array2d<T>* arr, bool fortranlike = false)
{
  if(DEBUG) {
    if(arr == NULL) {
      throw std::runtime_error("void oneDim2twoDim(const Array<T>& vec, size_t x, size_t y, Array2d<T>* arr) : arr == NULL");
    }
    if(xSize*ySize != vec.size()) {
      throw std::runtime_error("void oneDim2twoDim(const Array<T>& vec, size_t x, size_t y, Array2d<T>* arr) : "
                               "x*y != vec.size()");
    }
  }

  size_t currPos = 0;
  if(fortranlike) {  //store array by columns:
    for(size_t x = 0; x < xSize; ++x) {
      for(size_t y = 0; y < ySize; ++y) {
        (*arr)[x][y]=vec[currPos];
        ++currPos;
      }
    }
  }
  else {  //store array by rows:
    for(size_t y = 0; y < ySize; ++y) {
      for(size_t x = 0; x < xSize; ++x) {
        (*arr)[x][y]=vec[currPos];
        ++currPos;
      }
    }
  }
}


template<class T>
std::ostream& operator<<(std::ostream &os, const Array2d<T> &a)
{
  //save old format settings:
  std::ios::fmtflags oldSettings = os.flags();
  //formatting
  os.precision(2);
  for(size_t p2 = 0; p2 < a.dim2(); p2++) {
    for(size_t p1 = 0; p1 < a.dim1(); p1++) {
      std::cout<<" "<<a[p1][p2];
    }
    std::cout<<std::endl;
  }
  //rewrite old settings:
  os.flags(oldSettings);
  return os;
}



} // namespace

#endif // _SIMTH_CONTAINERS_H

---