AffineExprDetail.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/api.h>
#include <tvm/defs.h>
 
#include <Eigen/Core>
 
namespace tvm
{
namespace utils
{
namespace internal
{
 
using IdentityType = decltype(Eigen::MatrixXd::Identity());
using MultIdentityType = decltype(2. * Eigen::MatrixXd::Identity());
using MinusIdentityType = decltype(-Eigen::MatrixXd::Identity());
 
class NoConstant
{
public:
  NoConstant operator-() const { return {}; }
};
 
template<typename RhsType>
inline const RhsType & operator+(const NoConstant &, const Eigen::MatrixBase<RhsType> & rhs)
{ return rhs.derived(); }
 
template<typename LhsType>
inline const LhsType & operator+(const Eigen::MatrixBase<LhsType> & lhs, const NoConstant &)
{ return lhs.derived(); }
 
inline auto operator+(const NoConstant &, const NoConstant &) { return NoConstant(); }
 
template<typename MultType>
inline NoConstant operator*(const MultType & /*m*/, const NoConstant &)
{ return {}; }
 
template<typename Derived>
struct RefSelector
{
  using type = typename Eigen::internal::ref_selector<Derived>::type;
};
template<>
struct RefSelector<NoConstant>
{
  using type = NoConstant;
};
 
template<typename Derived>
using RefSelector_t = typename RefSelector<Derived>::type;
 
template<typename LhsType, typename RhsType>
using AddConstantsRetType =
    std::remove_const_t<std::remove_reference_t<decltype(std::declval<LhsType>() + std::declval<RhsType>())>>;
 
template<typename Tuple, size_t... Indices>
auto tupleUnaryMinus(const Tuple & tuple, std::index_sequence<Indices...>)
{ return std::make_tuple((-std::get<Indices>(tuple))...); }
 
template<typename MultType, typename Tuple, size_t... Indices>
auto tuplePremult(const MultType & m, const Tuple & tuple, std::index_sequence<Indices...>)
{ return std::make_tuple((m * std::get<Indices>(tuple))...); }
} // namespace internal
} // namespace utils
} // namespace tvm
 
namespace Eigen
{
namespace internal
{
template<>
struct traits<tvm::utils::internal::NoConstant> : public traits<tvm::utils::internal::IdentityType>
{};
} // namespace internal
} // namespace Eigen