GslVector.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-2017 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_GSL_VECTOR_H
#define UQ_GSL_VECTOR_H

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

#include <gsl/gsl_vector.h>

namespace QUESO {

class GslVector : public Vector
{
public:



  GslVector(const BaseEnvironment& env, const Map& map);

  GslVector(const BaseEnvironment& env, const Map& map, double value);

  //  like MATLAB linspace does.
  GslVector(const BaseEnvironment& env, double d1, double d2, const Map& map);

  GslVector(const GslVector&         v, double start, double end);

  GslVector(const GslVector&         y);

  ~GslVector();


  GslVector& operator= (const GslVector& rhs);

  GslVector& operator*=(double a);

  GslVector& operator/=(double a);

  GslVector& operator*=(const GslVector& rhs);

  GslVector& operator/=(const GslVector& rhs);

  GslVector& operator+=(const GslVector& rhs);

  GslVector& operator-=(const GslVector& rhs);



            double& operator[](unsigned int i);


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


  unsigned int sizeLocal        () const;

  unsigned int sizeGlobal       () const;


  double       norm2Sq          () const;

  double       norm2            () const;

  double       norm1            () const;

  double       normInf          () const;

  double       sumOfComponents  () const;


  void         cwSet            (double value);

  void         cwSetGaussian    (double mean, double stdDev);

  void         cwSetGaussian    (const GslVector& meanVec, const GslVector& stdDevVec);

  void         cwSetUniform     (const GslVector& aVec, const GslVector& bVec);

  void         cwSetBeta        (const GslVector& alpha, const GslVector& beta);

  void         cwSetGamma       (const GslVector& a, const GslVector& b);

  void         cwSetInverseGamma(const GslVector& alpha, const GslVector& beta);

  void         cwSetConcatenated(const GslVector& v1, const GslVector& v2);

  void         cwSetConcatenated(const std::vector<const GslVector* >& vecs);

  void         cwSet            (unsigned int initialPos, const GslVector& vec);

  void         cwExtract        (unsigned int initialPos, GslVector& vec) const;

  void         cwInvert         ();

  void         cwSqrt           ();


  void         print            (std::ostream& os) const;

  void         sort             ();

  void         matlabDiff       (unsigned int firstPositionToStoreDiff, double valueForRemainderPosition, GslVector& outputVec) const;
  void         matlabLinearInterpExtrap(const GslVector& x1Vec, const GslVector& y1Vec, const GslVector& x2Vec);
  void         mpiBcast         (int srcRank, const MpiComm& bcastComm);
  void         mpiAllReduce     (RawType_MPI_Op mpiOperation, const MpiComm& opComm, GslVector& resultVec) const;
  void         mpiAllQuantile   (double probability, const MpiComm& opComm, GslVector& resultVec) const;
  void         subWriteContents (const std::string&            varNamePrefix,
                                 const std::string&            fileName,
                                 const std::string&            fileType,
                                 const std::set<unsigned int>& allowedSubEnvIds) const;
  void         subReadContents  (const std::string&            fileName,
                                 const std::string&            fileType,
                                 const std::set<unsigned int>& allowedSubEnvIds);


  bool         atLeastOneComponentSmallerThan       (const GslVector& rhs) const;

  bool         atLeastOneComponentBiggerThan        (const GslVector& rhs) const;

  bool         atLeastOneComponentSmallerOrEqualThan(const GslVector& rhs) const;

  bool         atLeastOneComponentBiggerOrEqualThan (const GslVector& rhs) const;

  // Necessary for GslMatrix::invertMultiply() and GslMatrix::setRow/Column
  gsl_vector*  data                          () const;


  double       getMaxValue      () const;

  double       getMinValue      () const;

  int          getMaxValueIndex () const;

  int          getMinValueIndex () const;

  void         getMaxValueAndIndex( double& value, int& index );

  void         getMinValueAndIndex( double& value, int& index );

  GslVector abs() const;
private:

  GslVector();

  void         copy             (const GslVector& src);

  gsl_vector* m_vec;
};

// Comments in this part of file don't appear in the doxygen docs.

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


inline
double&
GslVector::operator[](unsigned int i)
{
  return *gsl_vector_ptr(m_vec,i);
}


inline
const double&
GslVector::operator[](unsigned int i) const
{
  return *gsl_vector_const_ptr(m_vec,i);
}


}  // End namespace QUESO

#endif // UQ_GSL_VECTOR_H