VariableVector.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/api.h>
#include <tvm/defs.h>
 
#include <tvm/internal/MatrixWithProperties.h>
#include <tvm/internal/ObjWithId.h>
 
#include <tvm/deprecated.hh>
 
#include <map>
#include <memory>
#include <set>
#include <vector>
 
namespace tvm
{
class TVM_DLLAPI VariableVector : public tvm::internal::ObjWithId
{
public:
  VariableVector();
  template<typename... VarPtr>
  VariableVector(VarPtr &&... variables);
 
  VariableVector(const VariableVector & other);
  VariableVector(VariableVector &&) = default;
 
  VariableVector & operator=(const VariableVector & other);
  VariableVector & operator=(VariableVector &&) = default;
 
  ~VariableVector();
 
  bool add(VariablePtr v);
  bool add(std::unique_ptr<Variable> v);
  void add(const std::vector<VariablePtr> & variables);
  void add(const VariableVector & variables);
  int addAndGetIndex(VariablePtr v, bool containingIndex = false);
 
  bool remove(const Variable & v);
  void remove(int i);
 
  void clear();
 
  int totalSize() const;
  int numberOfVariables() const;
  const VariablePtr operator[](int i) const;
  const std::vector<VariablePtr> & variables() const;
 
  const Eigen::VectorXd & value() const;
  TVM_DEPRECATED inline void value(const VectorConstRef & x) { set(x); }
  void set(const VectorConstRef & val);
  void setZero();
 
  bool contains(const Variable & v) const;
 
  bool intersects(const Variable & v) const;
 
  int indexOf(const Variable & v) const;
 
  Range getMappingOf(const Variable & v) const;
 
  int stamp() const;
 
  std::vector<VariablePtr>::const_iterator begin() const;
  std::vector<VariablePtr>::const_iterator end() const;
 
private:
  void add_(VariablePtr v);
  void remove_(std::vector<VariablePtr>::const_iterator it);
  void getNewStamp() const;
 
  static int counter;
 
  mutable int stamp_;
  int size_;
  std::vector<VariablePtr> variables_;
 
  mutable Eigen::VectorXd value_;
};
 
template<typename... VarPtr>
VariableVector::VariableVector(VarPtr &&... variables) : VariableVector()
{
  // clang-format off
    static_assert((... && (std::is_same_v<typename std::decay_t<VarPtr>, VariablePtr>
                        || std::is_same_v<typename std::decay_t<VarPtr>, std::unique_ptr<Variable>>
                        || std::is_same_v<typename std::decay_t<VarPtr>, VariableVector>
                        || std::is_same_v<typename std::decay_t<VarPtr>, std::vector<VariablePtr>>)));
  // clang-format on
  (add(std::forward<VarPtr>(variables)), ...);
}
 
VariableVector TVM_DLLAPI dot(const VariableVector & vars, int ndiff = 1);
 
inline std::vector<VariablePtr>::const_iterator tvm::VariableVector::begin() const { return variables_.begin(); }
 
inline std::vector<VariablePtr>::const_iterator tvm::VariableVector::end() const { return variables_.end(); }
 
} // namespace tvm