SubstitutionCalculatorImpl.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/api.h>
#include <tvm/defs.h>
 
#include <tvm/Range.h>
#include <tvm/VariableVector.h>
 
#include <vector>
 
namespace tvm
{
 
namespace hint
{
 
namespace abstract
{
class TVM_DLLAPI SubstitutionCalculatorImpl
{
public:
  virtual ~SubstitutionCalculatorImpl() = default;
  void update();
  void premultiplyByASharpAndSTranspose(MatrixRef outA, MatrixRef outS, const MatrixConstRef & in, bool minus) const;
  void postMultiplyByN(MatrixRef out, const MatrixConstRef & in, bool add = false) const;
  void postMultiplyByN(MatrixRef out, const MatrixConstRef & in, Range r, bool add = false) const;
  const Eigen::MatrixXd & N() const;
 
  Eigen::DenseIndex m() const;
  Eigen::DenseIndex n() const;
  Eigen::DenseIndex r() const;
 
protected:
  SubstitutionCalculatorImpl(const std::vector<LinearConstraintPtr> & cstr,
                             const std::vector<VariablePtr> & x,
                             int rank);
 
  void constant(bool c);
  bool constant() const;
 
  MatrixConstRef A() const;
 
  bool isSimple() const;
 
  virtual void update_() = 0;
  virtual void premultiplyByASharpAndSTranspose_(MatrixRef outA,
                                                 MatrixRef outS,
                                                 const MatrixConstRef & in,
                                                 bool minus) const = 0;
  virtual void postMultiplyByN_(MatrixRef out, const MatrixConstRef & in, bool add) const;
  virtual void postMultiplyByN_(MatrixRef out, const MatrixConstRef & in, Range r, bool add) const;
 
  void fillA();
 
  Eigen::MatrixXd N_;
  std::vector<LinearConstraintPtr> constraints_;
  VariableVector variables_;
 
private:
  struct FillData
  {
    VariablePtr x;
    LinearConstraintPtr cstr;
    Eigen::Block<Eigen::MatrixXd> block;
  };
 
  Eigen::DenseIndex m_; // row size of A
  Eigen::DenseIndex n_; // col size of A
  Eigen::DenseIndex r_; // rank of A
  bool constant_;       // constness of A
  bool init_;           // used to perform update_() only once if A is constant
  bool simple_;         // true if there is only one variable and one constraint
  Eigen::MatrixXd A_;   // aggregated matrix for non-simple case;
  std::vector<FillData> fillData_;
 
  friend class SubstitutionCalculator;
};
 
inline Eigen::DenseIndex SubstitutionCalculatorImpl::m() const { return m_; }
 
inline Eigen::DenseIndex SubstitutionCalculatorImpl::n() const { return n_; }
 
inline Eigen::DenseIndex SubstitutionCalculatorImpl::r() const { return r_; }
 
inline bool SubstitutionCalculatorImpl::isSimple() const { return simple_; }
 
} // namespace abstract
 
} // namespace hint
 
} // namespace tvm