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-2015 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(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:

  TeuchosVector();

  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