Distribution.h

Go to the documentation of this file.

#ifndef DISTRIBUTION_H_
#define DISTRIBUTION_H_
 
#include "MUQ/Modeling/WorkPiece.h"
#include "MUQ/Utilities/VariadicMacros.h"
 
#include "MUQ/Utilities/Exceptions.h"
 
#include <Eigen/Core>
#include <vector>
 
namespace muq {
  namespace Modeling {
 
    class Density;
    class RandomVariable;
 
    class Distribution : public std::enable_shared_from_this<Distribution> {
    public:
      friend class Density;
      friend class RandomVariable;
 
      Distribution(unsigned int           varSizeIn,
                   Eigen::VectorXi const& hyperSizesIn = Eigen::VectorXi()) : varSize(varSizeIn),
                                                                              hyperSizes(hyperSizesIn){};
 
      virtual ~Distribution() = default;
 
 
      virtual double LogDensity(ref_vector<Eigen::VectorXd> const& inputs);
      virtual double LogDensity(std::vector<Eigen::VectorXd> const& inputs){return LogDensity(ToRefVector(inputs));};;
      VARIADIC_TO_REFVECTOR(LogDensity, Eigen::VectorXd, double);
 
 
      virtual Eigen::VectorXd GradLogDensity(unsigned int wrt, std::vector<Eigen::VectorXd> const& inputs){return GradLogDensity(wrt, ToRefVector(inputs));};;
      virtual Eigen::VectorXd GradLogDensity(unsigned int wrt, ref_vector<Eigen::VectorXd> const& inputs);
 
      template<typename... Args>
        Eigen::VectorXd GradLogDensity(unsigned int wrt, Args... args) {
          ref_vector<Eigen::VectorXd> inputs;
          return GradLogDensity(wrt, inputs, args...);
      }
 
 
      virtual Eigen::VectorXd ApplyLogDensityHessian(unsigned int                const  inWrt1,
                                                     unsigned int                const  inWrt2,
                                                     ref_vector<Eigen::VectorXd> const& input,
                                                     Eigen::VectorXd             const& vec);
 
 
      virtual Eigen::VectorXd ApplyLogDensityHessian(unsigned int                 const  inWrt1,
                                                     unsigned int                 const  inWrt2,
                                                     std::vector<Eigen::VectorXd> const& input,
                                                     Eigen::VectorXd              const& vec){return ApplyLogDensityHessian(inWrt1,inWrt2,ToRefVector(input),vec);};
 
 
 
      Eigen::VectorXd Sample(ref_vector<Eigen::VectorXd> const& inputs);
      Eigen::VectorXd Sample(std::vector<Eigen::VectorXd> const& inputs){return Sample(ToRefVector(inputs));};
 
 
      Eigen::VectorXd Sample();
 
      VARIADIC_TO_REFVECTOR(Sample, Eigen::VectorXd, Eigen::VectorXd);
 
 
      std::shared_ptr<Density> AsDensity();
 
      std::shared_ptr<RandomVariable> AsVariable();
 
      const unsigned int    varSize;
      const Eigen::VectorXi hyperSizes;
 
    protected:
 
 
      virtual double LogDensityImpl(ref_vector<Eigen::VectorXd> const& inputs){
        throw  muq::NotImplementedError(std::string("LogDensityImpl function has not been implemented for class ") + typeid(*this).name());
        return 0;
      };
 
 
      virtual Eigen::VectorXd GradLogDensityImpl(unsigned int wrt, ref_vector<Eigen::VectorXd> const& inputs);
 
      virtual Eigen::VectorXd ApplyLogDensityHessianImpl(unsigned int wrt1, unsigned int wrt2, ref_vector<Eigen::VectorXd> const& inputs, Eigen::VectorXd const& vec);
 
 
      virtual Eigen::VectorXd SampleImpl(ref_vector<Eigen::VectorXd> const& inputs){
        throw  muq::NotImplementedError(std::string("SampleImpl function has not been implemented for class ") + typeid(*this).name());
        return Eigen::VectorXd();
      };
 
      ref_vector<const Eigen::VectorXd> ToRefVector(std::vector<Eigen::VectorXd> const& anyVec) const;
 
    private:
 
      template<typename... Args>
        Eigen::VectorXd GradLogDensity(unsigned int wrt, ref_vector<Eigen::VectorXd>& inputs, Eigen::VectorXd const& in, Args... args) {
        inputs.push_back(std::cref(in));
        return GradLogDensity(wrt, inputs, args...);
      }
    };
  } // namespace Modeling
} // namespace muq
 
#endif