ArrayOfSequences.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_ARRAY_OF_SEQUENCES_H
#define UQ_ARRAY_OF_SEQUENCES_H

#include <queso/VectorSequence.h>

namespace QUESO {

template <class V, class M>
class ArrayOfSequences : public BaseVectorSequence<V,M>
{
public:

  ArrayOfSequences(const VectorSpace<V,M>& vectorSpace,
                          unsigned int                   subSequenceSize,
                          const std::string&             name);
  ~ArrayOfSequences();


  unsigned int subSequenceSize      () const;

  void         resizeSequence       (unsigned int newSubSequenceSize);


  void         resetValues          (unsigned int initialPos, unsigned int numPos);


  void         erasePositions       (unsigned int initialPos, unsigned int numPos);

  void         getPositionValues    (unsigned int posId,       V& vec) const;


  void         setPositionValues    (unsigned int posId, const V& vec);


  void         setGaussian          (const V& meanVec, const V& stdDevVec);


  void         setUniform           (const V& aVec,    const V& bVec     );

  void         mean                 (unsigned int             initialPos,
                                     unsigned int             numPos,
                                     V&                       meanVec) const;
  // TODO not implemented.
  void         unifiedMean          (unsigned int             initialPos,
                                     unsigned int             numPos,
                                     V&                       unifiedMeanVec) const;
  void         sampleVariance       (unsigned int             initialPos,
                                     unsigned int             numPos,
                                     const V&                 meanVec,
                                     V&                       samVec) const;
  // TODO not implemented.
  void         unifiedSampleVariance(unsigned int             initialPos,
                                     unsigned int             numPos,
                                     const V&                 meanVec,
                                     V&                       samVec) const;
  void         populationVariance   (unsigned int             initialPos,
                                     unsigned int             numPos,
                                     const V&                 meanVec,
                                     V&                       popVec) const;

  void         autoCovariance       (unsigned int             initialPos,
                                     unsigned int             numPos,
                                     const V&                 meanVec,
                                     unsigned int             lag,
                                     V&                       covVec) const;

  void         autoCorrViaDef       (unsigned int             initialPos,
                                     unsigned int             numPos,
                                     unsigned int             lag,
                                     V&                       corrVec) const;
  void         autoCorrViaFft       (unsigned int                     initialPos,
                                     unsigned int                     numPos,
                                     const std::vector<unsigned int>& lags,
                                     std::vector<V*>&                 corrVecs) const;

  void         autoCorrViaFft       (unsigned int             initialPos,
                                     unsigned int             numPos,
                                     unsigned int             numSum,
                                     V&                       autoCorrsSumVec) const;
  void         minMax               (unsigned int             initialPos,
                                     V&                       minVec,
                                     V&                       maxVec) const;

  void         histogram            (unsigned int             initialPos,
                                     const V&                 minVec,
                                     const V&                 maxVec,
                                     std::vector<V*>&         centersForAllBins,
                                     std::vector<V*>&         quanttsForAllBins) const;


  void         interQuantileRange   (unsigned int             initialPos,
                                     V&                       iqrs) const;


  void         scalesForKDE         (unsigned int             initialPos,
                                     const V&                 iqrs,
                                     unsigned int             kdeDimension,
                                     V&                       scales) const;

  void         gaussianKDE          (const V&                 evaluationParamVec,
                                     V&                       densityVec) const;

  void         gaussianKDE          (unsigned int             initialPos,
                                     const V&                 scales,
                                     const std::vector<V*>&   evaluationParamVecs,
                                     std::vector<V*>&         densityVecs) const;
  void         writeContents        (std::ofstream&                   ofsvar) const;


  void         unifiedWriteContents (std::ofstream&                   ofsvar) const;


  void         unifiedWriteContents (const std::string&               fileName,
                                     const std::string&               fileType) const;


  void         unifiedReadContents  (const std::string&               fileName,
                                     const std::string&               fileType,
                                     const unsigned int               subSequenceSize);


  void         select               (const std::vector<unsigned int>& idsOfUniquePositions);


  void         filter               (unsigned int                     initialPos,
                                     unsigned int                     spacing);


  void         extractScalarSeq     (unsigned int                   initialPos,
                                     unsigned int                   spacing,
                                     unsigned int                   numPos,
                                     unsigned int                   paramId,
                                     ScalarSequence<double>& scalarSeq) const;

#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
  void         uniformlySampledMdf  (const V&                       numEvaluationPointsVec,
                                     ArrayOfOneDGrids <V,M>& mdfGrids,
                                     ArrayOfOneDTables<V,M>& mdfValues) const;
#endif

#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
  void         uniformlySampledCdf  (const V&                       numEvaluationPointsVec,
                                     ArrayOfOneDGrids <V,M>& cdfGrids,
                                     ArrayOfOneDTables<V,M>& cdfValues) const;
  void         bmm                  (unsigned int             initialPos,
                                     unsigned int             batchLength,
                                     V&                       bmmVec) const;
  void         fftForward           (unsigned int                        initialPos,
                                     unsigned int                        fftSize,
                                     unsigned int                        paramId,
                                     std::vector<std::complex<double> >& resultData) const;
//void         fftInverse           (unsigned int fftSize);

  void         psd                  (unsigned int             initialPos,
                                     unsigned int             numBlocks,
                                     double                   hopSizeRatio,
                                     unsigned int             paramId,
                                     std::vector<double>&     psdResult) const;
  void         psdAtZero            (unsigned int             initialPos,
                                     unsigned int             numBlocks,
                                     double                   hopSizeRatio,
                                     V&                       psdVec) const;
  void         geweke               (unsigned int             initialPos,
                                     double                   ratioNa,
                                     double                   ratioNb,
                                     V&                       gewVec) const;
#endif


private:

  void         extractRawData       (unsigned int                   initialPos,
                                     unsigned int                   spacing,
                                     unsigned int                   numPos,
                                     unsigned int                   paramId,
                                     std::vector<double>&           rawData) const;

  DistArray<ScalarSequence<double>*> m_scalarSequences;

  using BaseVectorSequence<V,M>::m_env;
  using BaseVectorSequence<V,M>::m_vectorSpace;
  using BaseVectorSequence<V,M>::m_name;
  using BaseVectorSequence<V,M>::m_fftObj;
};

}  // End namespace QUESO

#endif // UQ_ARRAY_OF_SEQUENCES_H