MultiIndexSet.h

Go to the documentation of this file.

#ifndef MULTIINDEXSET_H_
#define MULTIINDEXSET_H_
 
#include <vector>
#include <memory>
#include <set>
#include <map>
 
#include "MUQ/Utilities/MultiIndices/MultiIndex.h"
 
#include "MUQ/Utilities/MultiIndices/MultiIndexLimiter.h"
 
namespace muq{
  namespace Utilities{
 
    class H5Object;
    class MultiIndexSet;
    class MultiIndexFactory;
 
 
    std::shared_ptr<MultiIndexSet> operator+=( std::shared_ptr<MultiIndexSet> x,
                                               std::shared_ptr<MultiIndexSet> y);
 
    std::shared_ptr<MultiIndexSet> operator+=( std::shared_ptr<MultiIndexSet> x,
                                               std::shared_ptr<MultiIndex> y);
 
    class MultiIndexSet{
 
      friend class MultiIndexFactory;
 
    public:
 
      MultiIndexSet(const unsigned dimIn,
                    std::shared_ptr<MultiIndexLimiter> limiterIn = std::make_shared<NoLimiter>());
 
      static std::shared_ptr<MultiIndexSet> CloneExisting(std::shared_ptr<MultiIndexSet> const& original);
 
      virtual ~MultiIndexSet() = default;
 
      virtual void SetLimiter(std::shared_ptr<MultiIndexLimiter> const& limiterIn);
 
      virtual std::shared_ptr<MultiIndexLimiter> GetLimiter() const{return limiter;};
 
      // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
      // * * * FIXED COMPONENTS
      // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
      virtual std::vector<std::shared_ptr<MultiIndex>> GetAllMultiIndices() const {return allMultis;};
 
 
      virtual std::shared_ptr<MultiIndex> const& IndexToMulti(unsigned activeIndex) const{return allMultis.at(active2global.at(activeIndex));};
 
 
      virtual int MultiToIndex(std::shared_ptr<MultiIndex> const& input) const;
 
      virtual unsigned int GetMultiLength() const{return dim;};
 
      virtual Eigen::VectorXi GetMaxOrders() const{return maxOrders;};
 
      virtual std::shared_ptr<MultiIndex> const& at(int activeIndex){return IndexToMulti(activeIndex);}
 
      virtual std::shared_ptr<MultiIndex> operator[](int activeIndex){return allMultis[active2global[activeIndex]]; };
 
      virtual unsigned int Size() const{return active2global.size();};
 
      // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
      // * * * ADAPTIVE COMPONENTS
      // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
      virtual MultiIndexSet& operator+=(const MultiIndexSet &rhs);
 
      virtual MultiIndexSet& operator+=(std::shared_ptr<MultiIndex> const& rhs);
 
      virtual int Union(const MultiIndexSet &rhs);
 
      virtual void Activate(std::shared_ptr<MultiIndex> const& multiIndex);
 
      virtual int AddActive(std::shared_ptr<MultiIndex> const& newNode);
 
      virtual std::vector<unsigned> Expand(unsigned int activeIndex);
 
      virtual std::vector<unsigned> ForciblyExpand(unsigned int const activeIndex);
 
      virtual std::vector<unsigned> ForciblyActivate(std::shared_ptr<MultiIndex> const& multiIndex);
 
      virtual std::vector<std::shared_ptr<MultiIndex>>  GetAdmissibleForwardNeighbors(unsigned int activeIndex);
 
      virtual std::vector<unsigned int> GetFrontier() const;
 
      virtual std::vector<unsigned int> GetStrictFrontier() const;
 
      virtual std::vector<unsigned int> GetBackwardNeighbors(unsigned int activeIndex) const;
 
      virtual std::vector<unsigned int> GetBackwardNeighbors(std::shared_ptr<MultiIndex> const& multiIndex) const;
 
      //*********************************************************
      //Testing properties of an index/multiIndex
      //*********************************************************
 
      virtual bool IsAdmissible(std::shared_ptr<MultiIndex> const& multiIndex) const;
 
      virtual bool IsExpandable(unsigned int activeIndex) const;
 
      virtual bool IsActive(std::shared_ptr<MultiIndex> const& multiIndex) const;
 
      virtual unsigned int NumActiveForward(unsigned int activeInd) const;
 
      virtual unsigned int NumForward(unsigned int activeInd) const;
 
      void ToHDF5(std::string filename, std::string dsetName="/multiindices") const;
 
      void ToHDF5(muq::Utilities::H5Object &group, std::string dsetName="multiindices") const;
 
      static std::shared_ptr<MultiIndexSet> FromHDF5(std::string filename, std::string dsetName="/multiiindices");
 
      static std::shared_ptr<MultiIndexSet> FromHDF5(muq::Utilities::H5Object &dset);
 
    protected:
 
      int AddInactive(std::shared_ptr<MultiIndex> const& newNode);
 
      virtual bool IsAdmissible(unsigned int globalIndex) const;
      virtual bool IsActive(unsigned int globalIndex) const;
 
      void AddForwardNeighbors(unsigned int globalIndex, bool addInactive);
      void AddBackwardNeighbors(unsigned int globalIndex, bool addInactive);
 
      void Activate(int globalIndex);
      void ForciblyActivate(int localIndex, std::vector<unsigned int> &newInds);
 
      // Maps the active index to an entry in allMultis
      std::vector<unsigned> active2global;
 
      // Maps a global index to an active index.  Non-active values are -1
      std::vector<int> global2active;
 
      // a vector of sets for the input and output edges.
      std::vector<std::set<int>> outEdges; // edges going out of each multi
      std::vector<std::set<int>> inEdges;  // edges coming in to each multi
 
      Eigen::VectorXi maxOrders; // the maximum order in each dimension
 
      // the dimension (i.e., number of components) in each multi index
      unsigned int dim;
 
      // A vector of both active and admissable multiindices.  Global index.
      std::vector<std::shared_ptr<MultiIndex>> allMultis;
 
      // store a MultiIndexLimiter that will tell us the feasible set (i.e. simplex, exp limited, etc...)
      std::shared_ptr<MultiIndexLimiter> limiter;
 
    private:
 
      int AddMulti(std::shared_ptr<MultiIndex> const& newMulti);
 
      std::map<std::shared_ptr<MultiIndex>, unsigned int, MultiPtrComp> multi2global; // map from a multiindex to an integer
 
      MultiIndexSet() = default;
 
    }; // class MultiIndexSet
 
  } // namespace Utilities
} // namespace muq
 
 
 
 
#endif // MULTIINDEXSET_H_