Teuchos_TwoDArray.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS 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 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @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 const ArrayView<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){}
  bool _symmetrical;
};

template<class T> inline
ArrayView<T> TwoDArray<T>::operator[](size_type i){
  return _data.view(_numCols*i, _numCols);  
}

template<class T> inline
const ArrayView<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 TEUCHOS_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