MatrixProperties.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/api.h>
 
#include <utility>
 
namespace tvm
{
 
namespace internal
{
 
class TVM_DLLAPI MatrixProperties
{
public:
  enum Shape
  {
    GENERAL,
    LOWER_TRIANGULAR,
    UPPER_TRIANGULAR,
    DIAGONAL,
    MULTIPLE_OF_IDENTITY,
    IDENTITY,
    MINUS_IDENTITY,
    ZERO
  };
 
  enum Positiveness
  {
    NA,
    POSITIVE_SEMIDEFINITE,
    POSITIVE_DEFINITE,
    NEGATIVE_SEMIDEFINITE,
    NEGATIVE_DEFINITE,
    INDEFINITE,
    NON_ZERO_INDEFINITE
  };
 
  struct Constness
  {
  public:
    Constness(bool b = false) : b_(b) {}
    operator bool() const { return b_; }
 
  private:
    bool b_;
  };
 
  struct Invertibility
  {
  public:
    Invertibility(bool b = false) : b_(b) {}
    operator bool() const { return b_; }
 
  private:
    bool b_;
  };
 
  MatrixProperties();
  template<typename... Args>
  MatrixProperties(Args &&... args);
  MatrixProperties(const MatrixProperties &);
  MatrixProperties(MatrixProperties &);
  MatrixProperties(MatrixProperties &&) = default;
 
  MatrixProperties & operator=(const MatrixProperties &) = default;
  MatrixProperties & operator=(MatrixProperties &&) = default;
 
  Shape shape() const;
  Positiveness positiveness() const;
  Constness constness() const;
  Invertibility invertibility() const;
 
  bool isConstant() const;
  bool isInvertible() const;
  bool isTriangular() const;
  bool isLowerTriangular() const;
  bool isUpperTriangular() const;
  bool isDiagonal() const;
  bool isMultipleOfIdentity() const;
  bool isIdentity() const;
  bool isMinusIdentity() const;
  bool isZero() const;
  bool isSymmetric() const;
  bool isPositiveSemiDefinite() const;
  bool isPositiveDefinite() const;
  bool isNegativeSemidefinite() const;
  bool isNegativeDefinite() const;
  bool isIndefinite() const;
  bool isNonZeroIndefinite() const;
 
private:
#define ADD_ARGUMENT(T, member, b1, b2)                                         \
  T member = T();                                                               \
  template<typename... Args>                                                    \
  std::pair<bool, bool> processArgs(const T & m, const Args &... args)          \
  {                                                                             \
    static_assert(!check_args<T, Args...>(), #T " has already been specified"); \
    member = m;                                                                 \
    auto p = processArgs(args...);                                              \
    return {p.first || b1, p.second || b2};                                     \
  }
 
  struct Arguments
  {
    ADD_ARGUMENT(Shape, shape, false, false)
    ADD_ARGUMENT(Positiveness, positiveness, false, false)
    ADD_ARGUMENT(Constness, constant, true, false)
    ADD_ARGUMENT(Invertibility, invertible, false, true)
 
    std::pair<bool, bool> processArgs() { return {false, false}; }
 
  private:
    template<typename T, typename Arg0, typename... Args>
    static constexpr bool check_args()
    { return std::is_same<T, Arg0>::value || check_args<T, Args...>(); }
 
    template<typename T>
    static constexpr bool check_args()
    { return false; }
  };
 
  void build(const Arguments & args, const std::pair<bool, bool> & checks);
 
  bool constant_;
  bool invertible_;
  Shape shape_;
  bool symmetric_;
  Positiveness positiveness_;
};
 
// operators
TVM_DLLAPI MatrixProperties operator-(const MatrixProperties &);
TVM_DLLAPI MatrixProperties operator*(double, const MatrixProperties &);
TVM_DLLAPI MatrixProperties operator+(const MatrixProperties &, const MatrixProperties &);
TVM_DLLAPI MatrixProperties operator-(const MatrixProperties &, const MatrixProperties &);
TVM_DLLAPI MatrixProperties operator*(const MatrixProperties &, const MatrixProperties &);
 
template<typename... Args>
inline MatrixProperties::MatrixProperties(Args &&... args)
{
  Arguments a;
  auto p = a.processArgs(args...);
  build(a, p);
}
 
inline MatrixProperties::MatrixProperties(const MatrixProperties & other)
: constant_(other.constant_), invertible_(other.invertible_), shape_(other.shape_), symmetric_(other.symmetric_),
  positiveness_(other.positiveness_)
{}
 
inline MatrixProperties::MatrixProperties(MatrixProperties & other)
: MatrixProperties(const_cast<const MatrixProperties &>(other))
{}
 
inline MatrixProperties::Shape MatrixProperties::shape() const { return shape_; }
 
inline MatrixProperties::Positiveness MatrixProperties::positiveness() const { return positiveness_; }
 
inline MatrixProperties::Constness MatrixProperties::constness() const { return constant_; }
 
inline MatrixProperties::Invertibility MatrixProperties::invertibility() const { return invertible_; }
 
inline bool MatrixProperties::isConstant() const { return constant_; }
 
inline bool MatrixProperties::isInvertible() const { return invertible_; }
 
inline bool MatrixProperties::isTriangular() const { return shape_ >= Shape::LOWER_TRIANGULAR; }
 
inline bool MatrixProperties::isLowerTriangular() const { return shape_ == Shape::LOWER_TRIANGULAR || isDiagonal(); }
 
inline bool MatrixProperties::isUpperTriangular() const { return shape_ >= Shape::UPPER_TRIANGULAR; }
 
inline bool MatrixProperties::isDiagonal() const { return shape_ >= Shape::DIAGONAL; }
 
inline bool MatrixProperties::isMultipleOfIdentity() const { return shape_ >= Shape::MULTIPLE_OF_IDENTITY; }
 
inline bool MatrixProperties::isIdentity() const { return shape_ == Shape::IDENTITY; }
 
inline bool MatrixProperties::isMinusIdentity() const { return shape_ == Shape::MINUS_IDENTITY; }
 
inline bool MatrixProperties::isZero() const { return shape_ == Shape::ZERO; }
 
inline bool MatrixProperties::isSymmetric() const { return symmetric_; }
 
inline bool MatrixProperties::isPositiveSemiDefinite() const
{ return positiveness_ == Positiveness::POSITIVE_SEMIDEFINITE || isPositiveDefinite() || isZero(); }
 
inline bool MatrixProperties::isPositiveDefinite() const { return positiveness_ == Positiveness::POSITIVE_DEFINITE; }
 
inline bool MatrixProperties::isNegativeSemidefinite() const
{ return positiveness_ == Positiveness::NEGATIVE_SEMIDEFINITE || isNegativeDefinite() || isZero(); }
 
inline bool MatrixProperties::isNegativeDefinite() const { return positiveness_ == Positiveness::NEGATIVE_DEFINITE; }
 
inline bool MatrixProperties::isIndefinite() const { return positiveness_ != Positiveness::NA; }
 
inline bool MatrixProperties::isNonZeroIndefinite() const
{ return positiveness_ == Positiveness::NON_ZERO_INDEFINITE || isPositiveDefinite() || isNegativeDefinite(); }
 
} // namespace internal
 
} // namespace tvm