Teuchos_TwoDArray.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TEUCHOS_TWODARRAY_HPP
#define TEUCHOS_TWODARRAY_HPP
 
 
#include "Teuchos_Array.hpp"
 
 
namespace Teuchos{
 
template<class T>
class TwoDArray{
public:
  typedef Ordinal size_type;
 
 
  TwoDArray(size_type numRows, size_type numCols, T value=T()):
    _numRows(numRows),
    _numCols(numCols),
    _data(Array<T>(numCols*numRows, value)),
    _symmetrical(false)
    {}
  TwoDArray():
    _numRows(0),_numCols(0),_data(Array<T>()),_symmetrical(false){}
 
  virtual ~TwoDArray(){}
 
 
 
  inline ArrayView<T> operator[](size_type i);
 
  inline ArrayView<const T> operator[](size_type i) const;
 
  inline size_type getNumRows() const{
    return _numRows;
  }
 
  inline size_type getNumCols() const{
    return _numCols;
  }
 
  inline const Array<T>& getDataArray() const{
    return _data;
  }
 
  inline T& operator()(size_type i, size_type j){
    return _data[(i*_numCols)+j];
  }
 
  inline const T& operator()(size_type i, size_type j) const{
    return _data[(i*_numCols)+j];
  }
 
  inline void clear(){
    _data.clear();
    _numRows =0;
    _numCols =0;
  }
 
  inline bool isEmpty(){
    return _numRows == 0 &&
      _numCols == 0 &&
      _data.size() == 0;
  }
 
  inline bool isSymmetrical() const{
    return _symmetrical;
  }
 
  inline void setSymmetrical(bool symmetrical){
    _symmetrical = symmetrical;
  }
 
 
 
  void resizeRows(size_type numberOfRows);
 
  void resizeCols(size_type numberOfCols);
 
 
 
 
  static const std::string& getMetaSeperator(){
    static const std::string metaSeperator = ":";
    return metaSeperator;
  }
 
  static const std::string& getDimensionsDelimiter(){
    static const std::string dimensionsDelimiter = "x";
    return dimensionsDelimiter;
  }
 
  static std::string toString(const TwoDArray<T> array);
 
  static TwoDArray<T> fromString(const std::string& string);
 
 
private:
  size_type _numRows,_numCols;
  Array<T> _data;
  TwoDArray(size_type numRows, size_type numCols, Array<T> data):
    _numRows(numRows),
    _numCols(numCols),
    _data(data),
    _symmetrical(false)
  {}
 
  bool _symmetrical;
};
 
template<class T> inline
ArrayView<T> TwoDArray<T>::operator[](size_type i){
  return _data.view(_numCols*i, _numCols);
}
 
template<class T> inline
ArrayView<const T> TwoDArray<T>::operator[](size_type i) const{
  return _data.view(_numCols*i, _numCols);
}
 
template<class T>
void TwoDArray<T>::resizeRows(size_type numberOfRows){
  _data.resize(_numCols*numberOfRows);
  _numRows = numberOfRows;
}
 
 
template<class T>
void TwoDArray<T>::resizeCols(size_type numberOfCols){
  Array<T> newData(numberOfCols*_numRows);
  size_type colLimit = (numberOfCols < _numCols ? numberOfCols : _numCols);
  for(size_type i = 0; i<_numRows; i++){
    for(size_type j = 0; j<colLimit; j++){
      newData[i*numberOfCols+j] = _data[i*_numCols+j];
    }
  }
  _data = newData;
  _numCols=numberOfCols;
}
 
 
template<class T>
std::string TwoDArray<T>::toString(const TwoDArray<T> array){
  std::stringstream numColsStream;
  std::stringstream numRowsStream;
  numColsStream << array.getNumCols();
  numRowsStream << array.getNumRows();
  std::string metaSeperator = TwoDArray<T>::getMetaSeperator();
  return
    numRowsStream.str() +
    TwoDArray<T>::getDimensionsDelimiter() +
    numColsStream.str() +
    metaSeperator +
    (array.isSymmetrical() ? "sym"+metaSeperator : "") +
    array.getDataArray().toString();
}
 
template<class T>
TwoDArray<T> TwoDArray<T>::fromString(const std::string& string_in){
  std::string curString = string_in;
  std::string metaSeperator = TwoDArray<T>::getMetaSeperator();
  size_t curPos = curString.find(metaSeperator);
  std::string dimString = curString.substr(0, curPos);
  curString = curString.substr(curPos+1);
 
  //process dimensions
  size_t dimCharPos =
    dimString.find(TwoDArray<T>::getDimensionsDelimiter());
  std::istringstream numRowsStream(dimString.substr(0,dimCharPos));
  std::istringstream numColsStream(dimString.substr(dimCharPos+1));
  size_t numRows, numCols;
  numRowsStream >> numRows;
  numColsStream >> numCols;
 
  //determine symetry state
  bool symmetrical = false;
  curPos = curString.find(metaSeperator);
  if(curPos != std::string::npos){
    symmetrical = true;
    curString = curString.substr(curPos+1);
  }
 
  //Get actual data
  Array<T> array = fromStringToArray<T>(curString);
 
  TEUCHOS_TEST_FOR_EXCEPTION(array.size() != (typename Array<T>::size_type)(numRows*numCols),
    InvalidArrayStringRepresentation,
    "Error: You've specified an TwoDArray as having the dimensions of "
    << numRows << "x" << numCols << ". This means you should have " <<
    (numRows*numCols) << " entries specified in your array. However you "
    "only specified " << array.size() << " entries."
  )
 
  //Construct object to return
  TwoDArray<T> toReturn(numRows, numCols, array);
  toReturn.setSymmetrical(symmetrical);
  return toReturn;
}
 
/* \brief .
 * \relates TwoDArray
 */
template<class T>
std::istringstream& operator>> (std::istringstream& in, TwoDArray<T>& array){
  array = TwoDArray<T>::fromString(in.str());
  return in;
}
 
/* \brief .
 * \relates TwoDArray
 */
template<class T> inline
std::ostream& operator<<(std::ostream& os, const TwoDArray<T>& array){
  return os << TwoDArray<T>::toString(array);
}
 
 
namespace TwoDDetails {
 
template<typename T>
bool symmetricCompare(const TwoDArray<T> &a1, const TwoDArray<T> &a2 ){
  if(a1.getNumRows() != a2.getNumRows() ||
    a1.getNumRows() != a2.getNumRows())
  {
    return false;
  }
  else{
    typedef typename TwoDArray<T>::size_type ST;
    for(ST i=0;i<a1.getNumRows(); ++i){
      for(ST j=0;j<a1.getNumCols()-a1.getNumRows()+i; ++j){
        if(a1(i,j) != a2(i,j)){
          return false;
        }
      }
    }
    return true;
  }
}
 
 
}
 
/* \brief Returns true of the two TwoDArrays have the same contents and
 * their dimensions are the same.
 *
 * \note If the arrays are symmetrical, only the values in the upper half
 * of the array are compared. For example: in a 4x4 array, only the values
 * indicated with x's in the figure below would be compared.
 *
 *   o o o o
 *   x o o o
 *   x x o o
 *   x x x o
 *
 * \relates TwoDArray
 */
template<typename T>
bool operator==( const TwoDArray<T> &a1, const TwoDArray<T> &a2 ){
  if(a1.isSymmetrical() != a2.isSymmetrical()){
    return false;
  }
  if(a1.isSymmetrical()){
    return TwoDDetails::symmetricCompare(a1,a2);
  }
  else{
    return a1.getDataArray() == a2.getDataArray() &&
    a1.getNumRows() == a2.getNumRows() &&
    a1.getNumCols() == a2.getNumCols();
  }
}
 
inline
std::string getTwoDArrayTypeNameTraitsFormat(){
  return "TwoDArray(*)";
}
 
template<typename T>
class TEUCHOSCORE_LIB_DLL_EXPORT TypeNameTraits<TwoDArray<T> > {
public:
  static std::string name(){
    std::string formatString = getTwoDArrayTypeNameTraitsFormat();
    size_t starPos = formatString.find("*");
    std::string prefix = formatString.substr(0,starPos);
    std::string postFix = formatString.substr(starPos+1);
    return prefix+TypeNameTraits<T>::name()+postFix;
  }
  static std::string concreteName(const TwoDArray<T>&)
    { return name(); }
};
 
} //namespace Teuchos
 
 
#endif // TEUCHOS_TWODARRAY_H