MultiIndexLimiter.h

Go to the documentation of this file.

#ifndef MULTIINDEXLIMITER_H_
#define MULTIINDEXLIMITER_H_
 
#include <memory>
 
#include "MUQ/Utilities/MultiIndices/MultiIndex.h"
 
namespace muq{
namespace Utilities{
 
  class MultiIndexLimiter{
 
  public:
    virtual ~MultiIndexLimiter() = default;
 
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const = 0;
 
  }; // class MultiIndexLimiter
 
  class TotalOrderLimiter : public MultiIndexLimiter{
 
  public:
 
    TotalOrderLimiter(unsigned int totalOrderIn) : totalOrder(totalOrderIn){};
    virtual ~TotalOrderLimiter() = default;
 
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override {return (multi->Sum() <= totalOrder);};
 
  private:
    TotalOrderLimiter(){};
 
    unsigned int totalOrder;
 
  }; // class TotalOrderLimiter
 
 
  class DimensionLimiter : public MultiIndexLimiter{
 
  public:
 
    DimensionLimiter(unsigned int lowerDimIn, unsigned int lengthIn) : lowerDim(lowerDimIn), length(lengthIn){};
    virtual ~DimensionLimiter() = default;
 
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override;
 
  private:
    DimensionLimiter(){};
 
    unsigned int lowerDim;
    unsigned int length;
 
  }; // class DimensionLimiter
 
 
  class AnisotropicLimiter : public MultiIndexLimiter{
 
  public:
 
    AnisotropicLimiter(const Eigen::RowVectorXf& weightsIn, const double epsilonIn);
 
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override;
 
  private:
    const Eigen::RowVectorXf& weights;
    const double epsilon;
 
  }; // class AnisotropicLimiter
 
 
  /*
  class GeneralLimiter : public MultiIndexLimiter{
    friend class boost::serialization::access;
 
  public:
    GeneralLimiter(std::shared_ptr<MultiIndexSet> limitingSetIn) : limitingSet(limitingSetIn){};
    virtual ~GeneralLimiter() = default;
 
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override;
 
  private:
    GeneralLimiter(){};
 
    std::shared_ptr<MultiIndexSet> limitingSet;
 
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version){
      ar & boost::serialization::base_object<MultiIndexLimiter>(*this);
      ar & limitingSet;
    };
 
    };*/ // class GeneralLimiter
 
  class MaxOrderLimiter : public MultiIndexLimiter{
 
  public:
    MaxOrderLimiter(unsigned int maxOrderIn) : maxOrder(maxOrderIn){};
    MaxOrderLimiter(Eigen::VectorXi const& maxOrdersIn) : maxOrder(-1), maxOrders(maxOrdersIn), vectorMin(maxOrdersIn.minCoeff()){};
 
    virtual ~MaxOrderLimiter() = default;
 
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override;
 
  private:
    MaxOrderLimiter(){};
 
    int maxOrder;
    Eigen::VectorXi maxOrders;
    int vectorMin;
 
  }; // class MaxOrderLimiter
 
 class NoLimiter : public MultiIndexLimiter{
 
  public:
    virtual ~NoLimiter() = default;
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override {return true;};
 
  }; // class NoLimiter
 
 class AndLimiter : public MultiIndexLimiter{
 
  public:
    AndLimiter(std::shared_ptr<MultiIndexLimiter> limitA, std::shared_ptr<MultiIndexLimiter> limitB) : a(limitA), b(limitB){};
    virtual ~AndLimiter() = default;
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override {return (a->IsFeasible(multi)&&b->IsFeasible(multi));};
 
  private:
    AndLimiter(){};
    std::shared_ptr<MultiIndexLimiter> a, b;
 
  }; // class AndLimiter
 
  class OrLimiter : public MultiIndexLimiter{
 
  public:
    OrLimiter(std::shared_ptr<MultiIndexLimiter> limitA, std::shared_ptr<MultiIndexLimiter> limitB) : a(limitA), b(limitB){};
    virtual ~OrLimiter() = default;
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override {return (a->IsFeasible(multi)||b->IsFeasible(multi));};
 
  private:
    OrLimiter(){};
    std::shared_ptr<MultiIndexLimiter> a, b;
 
  }; // class OrLimiter
 
 
  class XorLimiter : public MultiIndexLimiter{
 
  public:
    XorLimiter(std::shared_ptr<MultiIndexLimiter> limitA, std::shared_ptr<MultiIndexLimiter> limitB) : a(limitA), b(limitB){};
    virtual ~XorLimiter() = default;
    virtual bool IsFeasible(std::shared_ptr<MultiIndex> multi) const override {return (a->IsFeasible(multi)^b->IsFeasible(multi));};
 
  private:
    XorLimiter(){};
    std::shared_ptr<MultiIndexLimiter> a, b;
 
  }; // class XorLimiter
 
} // namespace muq
} // namespace Utilities
 
#endif