Variable.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/Range.h>
#include <tvm/Space.h>
 
#include <tvm/internal/ObjWithId.h>
 
#include <tvm/deprecated.hh>
 
#include <Eigen/Core>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace tvm
{
class Variable;
class VariableVector;
 
VariablePtr TVM_DLLAPI dot(VariablePtr var, int ndiff = 1, bool autoName = false);
 
class TVM_DLLAPI Variable : public tvm::internal::ObjWithId, public std::enable_shared_from_this<Variable>
{
private:
  struct make_shared_token
  {};
 
public:
  Variable(const Variable &) = delete;
  Variable & operator=(const Variable &) = delete;
  ~Variable();
  VariablePtr duplicate(std::string_view name = "") const;
  const std::string & name() const;
  int size() const;
  const Space & space() const;
  const Space & spaceShift() const;
  bool isEuclidean() const;
  VectorConstRef value() const;
  TVM_DEPRECATED inline void value(const VectorConstRef & x) { set(x); }
  void set(const VectorConstRef & x);
  void set(Eigen::DenseIndex idx, double value);
  void set(Eigen::DenseIndex idx, Eigen::DenseIndex length, const VectorConstRef & value);
  void setZero();
  int derivativeNumber() const;
  bool isDerivativeOf(const Variable & v) const;
  bool isPrimitiveOf(const Variable & v) const;
  bool isBasePrimitive() const;
  template<int n = 1>
  VariablePtr primitive() const;
  VariablePtr basePrimitive() const;
 
  bool isSubvariable() const;
  VariablePtr superVariable() const;
  bool isSuperVariable() const;
  bool isSuperVariableOf(const Variable & v) const;
  Range subvariableRange() const;
  Range tSubvariableRange() const;
  bool contains(const Variable & v) const;
  bool intersects(const Variable & v) const;
 
  [[nodiscard]] VariablePtr subvariable(Space space, std::string_view baseName, Space shift = {0}) const;
 
  [[nodiscard]] VariablePtr subvariable(Space space, Space shift = {0}) const;
 
  Range getMappingIn(const VariableVector & variables) const;
 
  [[nodiscard]] VariablePtr shared_from_this();
 
  Eigen::CommaInitializer<VectorRef> operator<<(double d);
 
  template<typename Derived>
  Eigen::CommaInitializer<VectorRef> operator<<(const Eigen::DenseBase<Derived> & other);
 
  friend bool operator==(const Variable & u, const Variable & v);
  friend bool operator!=(const Variable & u, const Variable & v);
 
  Variable(make_shared_token, VariablePtr var, const Space & space, std::string_view name, const Space & shift);
 
private:
  struct MappingHelper
  {
    int start;
    int stamp;
  };
 
  Variable(const Space & s, std::string_view name);
 
  Variable(Variable * var, bool autoName);
 
  [[nodiscard]] VariablePtr subvariable(Space space, std::string_view baseName, Space shift, bool autoName) const;
 
  template<int n>
  VariablePtr primitiveNoCheck() const;
 
  std::string name_;
 
  Space space_;
 
  Space shift_;
 
  double * memory_;
 
  VectorRef value_;
 
  int derivativeNumber_;
 
  Variable * primitive_;
 
  VariablePtr superVariable_;
 
  std::unique_ptr<Variable> derivative_;
 
  mutable std::unordered_map<int, MappingHelper> startIn_;
 
  friend class Space;
  friend VariablePtr TVM_DLLAPI dot(VariablePtr, int, bool);
  friend class VariableVector;
};
 
template<int n>
inline VariablePtr Variable::primitive() const
{
  if(n <= derivativeNumber_)
    return primitiveNoCheck<n>();
  else
    throw std::runtime_error("This variable is not the n-th derivative of an other variable.");
}
 
template<int n>
inline VariablePtr Variable::primitiveNoCheck() const
{
  static_assert(n > 0, "Works only for non-negative numbers.");
  return primitive_->primitive<n - 1>();
}
 
template<>
inline VariablePtr Variable::primitiveNoCheck<1>() const
{
  if(derivativeNumber_ > 1)
    return {basePrimitive(), primitive_};
  else
    return primitive_->shared_from_this();
}
 
inline Eigen::CommaInitializer<VectorRef> Variable::operator<<(double d) { return {value_, d}; }
 
template<typename Derived>
inline Eigen::CommaInitializer<VectorRef> Variable::operator<<(const Eigen::DenseBase<Derived> & other)
{ return {value_, other}; }
 
inline bool operator==(const Variable & u, const Variable & v)
{ return u.value_.data() == v.value_.data() && u.size() == v.size(); }
 
inline bool operator!=(const Variable & u, const Variable & v) { return !(u == v); }
 
} // namespace tvm
 
inline Eigen::CommaInitializer<tvm::VectorRef> operator<<(tvm::VariablePtr & v, double d) { return *v.get() << d; }
 
inline Eigen::CommaInitializer<tvm::VectorRef> operator<<(tvm::VariablePtr && v, double d) { return *v.get() << d; }
 
template<typename Derived>
inline Eigen::CommaInitializer<tvm::VectorRef> operator<<(tvm::VariablePtr & v, const Eigen::DenseBase<Derived> & other)
{ return *v.get() << other; }
 
template<typename Derived>
inline Eigen::CommaInitializer<Eigen::VectorXd> operator<<(tvm::VariablePtr && v,
                                                           const Eigen::DenseBase<Derived> & other)
{ return *v.get() << other; }