AffineExprOperators.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/utils/AffineExpr.h>
 
namespace tvm
{
 
namespace utils
{
 
template<typename Derived>
inline auto operator-(const tvm::utils::LinearExpr<Derived> & lin)
{
  return tvm::utils::LinearExpr<std::remove_const_t<decltype(-std::declval<Derived>())>>(-lin.matrix(), lin.variable());
}
 
template<typename CstDerived, typename... Derived>
inline auto operator-(const tvm::utils::AffineExpr<CstDerived, Derived...> & aff)
{
  return make_AffineExpr(-aff.constant(), tvm::utils::internal::tupleUnaryMinus(
                                              aff.linear(), std::make_index_sequence<sizeof...(Derived)>{}));
}
 
template<typename MultDerived, typename CstDerived, typename... Derived>
inline auto operator*(const MultDerived & m, const tvm::utils::AffineExpr<CstDerived, Derived...> & aff)
{
  return make_AffineExpr(m * aff.constant(), tvm::utils::internal::tuplePremult(
                                                 m, aff.linear(), std::make_index_sequence<sizeof...(Derived)>{}));
}
 
template<typename Derived, typename CstDerived>
inline tvm::utils::AffineExpr<CstDerived, Derived> operator+(const tvm::utils::LinearExpr<Derived> & lin,
                                                             const Eigen::MatrixBase<CstDerived> & cst)
{ return {cst, lin}; }
 
template<typename Derived, typename CstDerived>
inline tvm::utils::AffineExpr<CstDerived, Derived> operator+(const Eigen::MatrixBase<CstDerived> & cst,
                                                             const tvm::utils::LinearExpr<Derived> & lin)
{ return {cst, lin}; }
 
template<typename LhsDerived, typename RhsDerived>
inline tvm::utils::AffineExpr<tvm::utils::internal::NoConstant, LhsDerived, RhsDerived> operator+(
    const tvm::utils::LinearExpr<LhsDerived> & lhs,
    const tvm::utils::LinearExpr<RhsDerived> & rhs)
{ return {lhs, rhs}; }
 
template<typename RhsDerived, typename CstDerived, typename... LhsDerived>
inline tvm::utils::AffineExpr<CstDerived, LhsDerived..., RhsDerived> operator+(
    const tvm::utils::AffineExpr<CstDerived, LhsDerived...> & lhs,
    const tvm::utils::LinearExpr<RhsDerived> & rhs)
{ return {lhs.constant(), std::tuple_cat(lhs.linear(), std::forward_as_tuple(rhs))}; }
 
template<typename LhsDerived, typename CstDerived, typename... RhsDerived>
inline tvm::utils::AffineExpr<CstDerived, LhsDerived, RhsDerived...> operator+(
    const tvm::utils::LinearExpr<LhsDerived> & lhs,
    const tvm::utils::AffineExpr<CstDerived, RhsDerived...> & rhs)
{ return {rhs.constant(), std::tuple_cat(std::forward_as_tuple(lhs), rhs.linear())}; }
 
template<typename RhsDerived, typename CstDerived, typename... LhsDerived>
inline tvm::utils::AffineExpr<tvm::utils::internal::AddConstantsRetType<CstDerived, RhsDerived>, LhsDerived...>
    operator+(const tvm::utils::AffineExpr<CstDerived, LhsDerived...> & lhs, const Eigen::MatrixBase<RhsDerived> & rhs)
{ return {lhs.constant() + rhs, lhs.linear()}; }
 
template<typename LhsDerived, typename CstDerived, typename... RhsDerived>
inline tvm::utils::AffineExpr<tvm::utils::internal::AddConstantsRetType<LhsDerived, CstDerived>, RhsDerived...>
    operator+(const Eigen::MatrixBase<LhsDerived> & lhs, const tvm::utils::AffineExpr<CstDerived, RhsDerived...> & rhs)
{ return {lhs + rhs.constant(), rhs.linear()}; }
 
template<typename LCstDerived, typename RCstDerived, typename... LhsDerived, typename... RhsDerived>
inline tvm::utils::
    AffineExpr<tvm::utils::internal::AddConstantsRetType<LCstDerived, RCstDerived>, LhsDerived..., RhsDerived...>
    operator+(const tvm::utils::AffineExpr<LCstDerived, LhsDerived...> & lhs,
              const tvm::utils::AffineExpr<RCstDerived, RhsDerived...> & rhs)
{ return {lhs.constant() + rhs.constant(), std::tuple_cat(lhs.linear(), rhs.linear())}; }
 
template<typename MultType, typename Derived>
inline auto operator*(const MultType & m, const tvm::utils::LinearExpr<Derived> & lin)
{
  return tvm::utils::LinearExpr<std::remove_const_t<decltype(m * std::declval<Derived>())>>(m * lin.matrix(),
                                                                                            lin.variable());
}
 
template<typename Derived,
         typename SubType,
         typename tvm::internal::
             enable_for_templated_t<SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr> = 0>
inline auto operator-(const tvm::utils::LinearExpr<Derived> & lin, const SubType & rhs)
{ return lin + -rhs; }
 
template<typename CstDerived,
         typename SubType,
         typename... Derived,
         typename tvm::internal::
             enable_for_templated_t<SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr> = 0>
inline auto operator-(const tvm::utils::AffineExpr<CstDerived, Derived...> & aff, const SubType & rhs)
{ return aff + -rhs; }
 
} // namespace utils
 
template<typename Derived>
inline tvm::utils::LinearExpr<Derived> operator*(const Eigen::MatrixBase<Derived> & matrix, const tvm::VariablePtr & v)
{ return {matrix, v}; }
 
inline tvm::utils::LinearExpr<tvm::utils::internal::MinusIdentityType> operator-(const tvm::VariablePtr & v)
{ return v; }
 
inline tvm::utils::LinearExpr<tvm::utils::internal::MultIdentityType> operator*(double s, const tvm::VariablePtr & v)
{
  assert(s != 0);
  return {s, v};
}
 
inline auto operator+(const tvm::VariablePtr & u, const tvm::VariablePtr & v)
{
  return tvm::utils::LinearExpr<tvm::utils::internal::IdentityType>(u)
         + tvm::utils::LinearExpr<tvm::utils::internal::IdentityType>(v);
}
 
template<typename AddType,
         typename tvm::internal::
             enable_for_templated_t<AddType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr> = 0>
inline auto operator+(const AddType & a, const tvm::VariablePtr & v)
{ return a + tvm::utils::LinearExpr<tvm::utils::internal::IdentityType>(v); }
 
template<typename AddType,
         typename tvm::internal::
             enable_for_templated_t<AddType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr> = 0>
inline auto operator+(const tvm::VariablePtr & v, const AddType & a)
{ return tvm::utils::LinearExpr<tvm::utils::internal::IdentityType>(v) + a; }
 
inline auto operator-(const tvm::VariablePtr & u, const tvm::VariablePtr & v)
{
  return tvm::utils::LinearExpr<tvm::utils::internal::IdentityType>(u)
         + tvm::utils::LinearExpr<tvm::utils::internal::MinusIdentityType>(v);
}
 
template<typename SubType,
         typename tvm::internal::
             enable_for_templated_t<SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr> = 0>
inline auto operator-(const SubType & a, const tvm::VariablePtr & v)
{ return a + tvm::utils::LinearExpr<tvm::utils::internal::MinusIdentityType>(v); }
 
template<typename SubType,
         typename tvm::internal::
             enable_for_templated_t<SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr> = 0>
inline auto operator-(const tvm::VariablePtr & v, const SubType & a)
{ return tvm::utils::LinearExpr<tvm::utils::internal::IdentityType>(v) + -a; }
 
} // namespace tvm