TeuchosVector.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// QUESO - a library to support the Quantification of Uncertainty
// for Estimation, Simulation and Optimization
//
// Copyright (C) 2008,2009,2010,2011,2012,2013 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// 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. 51 Franklin Street, Fifth Floor,
// Boston, MA  02110-1301  USA
//
//-----------------------------------------------------------------------el-

#ifndef UQ_TEUCHOS_VECTOR_H
#define UQ_TEUCHOS_VECTOR_H

#ifdef QUESO_HAS_TRILINOS
#include <Teuchos_SerialDenseVector.hpp>
#include <Teuchos_SerialDenseMatrix.hpp>
#include <Teuchos_LAPACK.hpp>
#endif

#include <queso/Defines.h>
#include <queso/Vector.h>
#include <vector>

#ifdef QUESO_HAS_TRILINOS

namespace QUESO {

class TeuchosVector : public Vector
{
public:
  



  TeuchosVector();
  
  TeuchosVector(const BaseEnvironment& env, const Map& map);
  
  TeuchosVector(const BaseEnvironment& env, const Map& map, double value);
  
  TeuchosVector(const BaseEnvironment& env, double d1, double d2, const Map& map);
 
  TeuchosVector(const TeuchosVector&         v, double d1, double d2);                   
  
  TeuchosVector(const TeuchosVector&         y);
  
  ~TeuchosVector();
  


  TeuchosVector& operator= (double a);
  
  TeuchosVector& operator= (const TeuchosVector& rhs);
  
  TeuchosVector& operator*=(double a);
  
  TeuchosVector& operator/=(double a);
  
  TeuchosVector& operator*=(const TeuchosVector& rhs);
  
  TeuchosVector& operator/=(const TeuchosVector& rhs);
  
  TeuchosVector& operator+=(const TeuchosVector& rhs);
  
  TeuchosVector& operator-=(const TeuchosVector& rhs);


  double& operator[](unsigned int i);
  
  const double& operator[](unsigned int i) const;


  unsigned int sizeLocal        () const;
  
  unsigned int sizeGlobal       () const;
  
  //TODO
  double*      values           () ;
  
  double       getMaxValue      () const;
  
  double       getMinValue      () const;
  
  int          getMaxValueIndex () const;
  
  int          getMinValueIndex () const;
  
  void         getMaxValueAndIndex( double& value, int& index );
  
  void         getMinValueAndIndex( double& value, int& index );
  

  double       norm2Sq          () const;
  
  double       norm2            () const;
  
  double       norm1            () const;
  
  double       normInf          () const;
  
   
  
    

  bool         atLeastOneComponentSmallerThan       (const TeuchosVector& rhs) const;
  
  bool         atLeastOneComponentBiggerThan        (const TeuchosVector& rhs) const;
  
  bool         atLeastOneComponentSmallerOrEqualThan(const TeuchosVector& rhs) const;
  
  bool         atLeastOneComponentBiggerOrEqualThan (const TeuchosVector& rhs) const;
  

  void         cwSet(double value);
  
  void         cwSet(unsigned int initialPos, const TeuchosVector& vec);
  
  void         cwExtract(unsigned int initialPos, TeuchosVector& vec) const; 
  
  void         cwInvert();
  
  void         cwSqrt();
  
  void         cwSetConcatenated(const TeuchosVector& v1, const TeuchosVector& v2);
  
  void         cwSetGaussian(double mean, double stdDev);
  
  void         cwSetGaussian(const TeuchosVector& meanVec,       const TeuchosVector& stdDevVec);
  
  void         cwSetUniform (const TeuchosVector& lowerBoundVec, const TeuchosVector& upperBoundVec);
  
  void         cwSetBeta        (const TeuchosVector& alpha,   const TeuchosVector& beta     );
  
  void         cwSetGamma       (const TeuchosVector& a,       const TeuchosVector& b        );
    
  void         cwSetInverseGamma(const TeuchosVector& a,   const TeuchosVector& b     );
  

  
  TeuchosVector abs() const;
      

  void          copy_to_std_vector(std::vector<double>& vec); // output
  

  void          copy_from_std_vector(const std::vector<double> vec); 
  

  void         sort             ();
  
  double       sumOfComponents  () const;
  
  void         mpiBcast         (int srcRank, const MpiComm& bcastComm);
  
  void         mpiAllReduce     (RawType_MPI_Op mpiOperation, const MpiComm& opComm, TeuchosVector& resultVec) const;
  
  void         mpiAllQuantile   (double probability, const MpiComm& opComm, TeuchosVector& resultVec) const;
 

  void         matlabLinearInterpExtrap(const TeuchosVector& xVec, const TeuchosVector& yVec, const TeuchosVector& xiVec);
  
  //TODO
  void         matlabDiff       (unsigned int firstPositionToStoreDiff, double valueForRemainderPosition, TeuchosVector& outputVec) const;

  

  void         print            (std::ostream& os) const;
  void         subReadContents  (const std::string&            fileName,
                                                                 const std::string&            fileType,
                                                                 const std::set<unsigned int>& allowedSubEnvIds);
  void         subWriteContents (const std::string&            varNamePrefix,
                                 const std::string&            fileName,
                                 const std::string&            fileType,
                                 const std::set<unsigned int>& allowedSubEnvIds) const;
                                 

  


private:
  
  Teuchos::SerialDenseVector<int,double> m_vec;
  
  void         copy             (const TeuchosVector& src);

};

//TeuchosVector copy              (int ,                                                    double []);
TeuchosVector operator/    (double a,                               const TeuchosVector& x  );
TeuchosVector operator/    (const TeuchosVector& x,   const TeuchosVector& y  );
TeuchosVector operator*    (double a,                           const TeuchosVector& x  );
TeuchosVector operator*    (const TeuchosVector& x,   const TeuchosVector& y  );
double               scalarProduct(const TeuchosVector& x,   const TeuchosVector& y  );
TeuchosVector operator+    (const TeuchosVector& x,   const TeuchosVector& y  );
TeuchosVector operator-    (const TeuchosVector& x,   const TeuchosVector& y  );
bool                 operator==   (const TeuchosVector& lhs, const TeuchosVector& rhs);
std::ostream&        operator<<   (std::ostream& os,                const TeuchosVector& obj);

}  // End namespace QUESO

#endif // ifdef QUESO_HAS_TRILINOS

#endif //UQ_TEUCHOS_VECTOR_H