Regression.h

Go to the documentation of this file.

#ifndef REGRESSION_H_
#define REGRESSION_H_
 
#include <boost/property_tree/ptree.hpp>
 
#include <Eigen/QR>
 
#include "MUQ/Utilities/MultiIndices/MultiIndexFactory.h"
 
#include "MUQ/Modeling/LinearAlgebra/AnyAlgebra.h"
#include "MUQ/Modeling/WorkPiece.h"
 
#include "MUQ/Optimization/CostFunction.h"
 
#include "MUQ/Approximation/Polynomials/IndexedScalarBasis.h"
 
namespace muq {
  namespace Approximation {
    class Regression : public muq::Modeling::WorkPiece, public std::enable_shared_from_this<Regression> {
    public:
 
      Regression(boost::property_tree::ptree const& pt);
 
 
      void Fit(std::vector<Eigen::VectorXd> xs, std::vector<Eigen::VectorXd> const& ys, Eigen::VectorXd const& center);
 
 
      void Fit(std::vector<Eigen::VectorXd> const& xs, std::vector<Eigen::VectorXd> const& ys);
 
      int NumInterpolationPoints() const;
 
      std::pair<Eigen::VectorXd, double> PoisednessConstant(std::vector<Eigen::VectorXd> xs, Eigen::VectorXd const& center, int kn = -1) const;
 
      const unsigned int order;
 
    private:
 
      virtual void EvaluateImpl(muq::Modeling::ref_vector<boost::any> const& inputs) override;
 
      void ComputeBasisDerivatives(Eigen::VectorXd const& point, std::vector<Eigen::VectorXd>& gradient) const;
 
 
      Eigen::MatrixXd ComputeCoefficients(std::vector<Eigen::VectorXd> const& xs, std::vector<Eigen::VectorXd> const& ys) const;
 
 
      Eigen::MatrixXd ComputeCoefficientsRHS(Eigen::MatrixXd const& vand, std::vector<Eigen::VectorXd> const& ys_data) const;
 
 
      Eigen::MatrixXd VandermondeMatrix(std::vector<Eigen::VectorXd> const& xs) const;
 
 
      Eigen::ArrayXd CenterPoints(std::vector<Eigen::VectorXd>& xs);
 
 
      Eigen::ArrayXd CenterPoints(std::vector<Eigen::VectorXd>& xs, Eigen::VectorXd const& center) const;
 
 
      Eigen::ArrayXd CenterPoints(std::vector<Eigen::VectorXd>& xs, Eigen::VectorXd const& center, unsigned int const kn) const;
 
      class PoisednessCost : public muq::Optimization::CostFunction {
      public:
 
           PoisednessCost(std::shared_ptr<Regression const> parent, std::vector<Eigen::RowVectorXd> const& lagrangeCoeff, unsigned int const inDim);
 
            virtual ~PoisednessCost() = default;
 
          virtual double Cost() override;
 
      private:
 
            virtual void GradientImpl(unsigned int outWrt, unsigned int inWrt, muq::Modeling::ref_vector<Eigen::VectorXd> const& input, Eigen::VectorXd const& sensitivity) override;
 
            std::shared_ptr<Regression const> parent;
 
            const std::vector<Eigen::RowVectorXd>& lagrangeCoeff;
      };
 
      class PoisednessConstraint : public muq::Modeling::ModPiece {
      public:
 
           PoisednessConstraint(unsigned int const inDim, double const alpha);
 
            virtual ~PoisednessConstraint() = default;
 
      private:
 
      virtual void EvaluateImpl(muq::Modeling::ref_vector<Eigen::VectorXd> const& input) override;
 
      virtual void JacobianImpl(unsigned int const outputDimWrt,
                                      unsigned int const inputDimWrt,
                                      muq::Modeling::ref_vector<Eigen::VectorXd> const& input) override;
 
          const double alpha;
      };
 
      const unsigned int inputDim;
 
 
      const double alpha;
 
      std::shared_ptr<muq::Utilities::MultiIndexSet> multi;
 
      std::shared_ptr<IndexedScalarBasis> poly;
 
      Eigen::VectorXd currentCenter;
 
      Eigen::ArrayXd currentRadius;
 
      Eigen::MatrixXd coeff;
 
      boost::property_tree::ptree optPt;
    };
  } // namespace Approximation
} // namespace muq
 
#endif