#include <tvm/api.h>#include <tvm/utils/AffineExpr.h>#include <tvm/utils/internal/ProtoTaskDetails.h>
Go to the source code of this file.
Classes | |
| class | tvm::utils::ProtoTaskCommon< T, FunT > |
| class | tvm::utils::ProtoTaskCommon< constraint::Type::DOUBLE_SIDED, FunT > |
Namespaces | |
| tvm | |
| tvm::utils | |
Macros | |
| #define | TVM_ID(x) std::make_shared<tvm::function::IdentityFunction>(x) |
| #define | TVM_LIN(x) std::make_shared<tvm::function::BasicLinearFunction>(x) |
Typedefs | |
| template<constraint::Type T> | |
| using | tvm::utils::ProtoTask = ProtoTaskCommon< T, FunctionPtr > |
| template<constraint::Type T> | |
| using | tvm::utils::LinearProtoTask = ProtoTaskCommon< T, LinearFunctionPtr > |
| template<typename T , typename IfNotLinearFunction , typename IfLinearFunction > | |
| using | tvm::utils::ProtoChoice = typename std::enable_if< std::is_base_of< tvm::function::abstract::Function, T >::value, typename std::conditional< std::is_base_of< tvm::function::abstract::LinearFunction, T >::value, IfLinearFunction, IfNotLinearFunction >::type >::type |
| using | tvm::utils::ProtoTaskEQ = ProtoTask< constraint::Type::EQUAL > |
| using | tvm::utils::LinearProtoTaskEQ = LinearProtoTask< constraint::Type::EQUAL > |
| template<typename T > | |
| using | tvm::utils::ProtoTaskEQRet = ProtoChoice< T, tvm::utils::ProtoTaskEQ, tvm::utils::LinearProtoTaskEQ > |
| using | tvm::utils::ProtoTaskLT = ProtoTask< constraint::Type::LOWER_THAN > |
| using | tvm::utils::LinearProtoTaskLT = LinearProtoTask< constraint::Type::LOWER_THAN > |
| template<typename T > | |
| using | tvm::utils::ProtoTaskLTRet = ProtoChoice< T, tvm::utils::ProtoTaskLT, tvm::utils::LinearProtoTaskLT > |
| using | tvm::utils::ProtoTaskGT = ProtoTask< constraint::Type::GREATER_THAN > |
| using | tvm::utils::LinearProtoTaskGT = LinearProtoTask< constraint::Type::GREATER_THAN > |
| template<typename T > | |
| using | tvm::utils::ProtoTaskGTRet = ProtoChoice< T, tvm::utils::ProtoTaskGT, tvm::utils::LinearProtoTaskGT > |
| using | tvm::utils::ProtoTaskDS = ProtoTask< constraint::Type::DOUBLE_SIDED > |
| using | tvm::utils::LinearProtoTaskDS = LinearProtoTask< constraint::Type::DOUBLE_SIDED > |
| template<typename T > | |
| using | tvm::utils::ProtoTaskDSRet = ProtoChoice< T, tvm::utils::ProtoTaskDS, tvm::utils::LinearProtoTaskDS > |
Macro Definition Documentation
◆ TVM_ID
| #define TVM_ID | ( | x | ) | std::make_shared<tvm::function::IdentityFunction>(x) |
◆ TVM_LIN
| #define TVM_LIN | ( | x | ) | std::make_shared<tvm::function::BasicLinearFunction>(x) |
Function Documentation
◆ operator<=() [1/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator<=() [2/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator<=() [3/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator<=() [4/9]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator<=() [5/9]
|
inline |
Convenience operators to form a LinearProtoTask x op rhs (or l <= x <= u)
- Parameters
-
x the variable used in the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator<=() [6/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator<=() [7/9]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator<=() [8/9]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator<=() [9/9]
|
inline |
Convenience operators to form a LinearProtoTask x op rhs (or l <= x <= u)
- Parameters
-
x the variable used in the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator==() [1/8]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator==() [2/8]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator==() [3/8]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator==() [4/8]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator==() [5/8]
|
inline |
Convenience operators to form a LinearProtoTask x op rhs (or l <= x <= u)
- Parameters
-
x the variable used in the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator==() [6/8]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator==() [7/8]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator==() [8/8]
|
inline |
Convenience operators to form a LinearProtoTask x op rhs (or l <= x <= u)
- Parameters
-
x the variable used in the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator>=() [1/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator>=() [2/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator>=() [3/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator>=() [4/9]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator>=() [5/9]
|
inline |
Convenience operators to form a LinearProtoTask x op rhs (or l <= x <= u)
- Parameters
-
x the variable used in the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator>=() [6/9]
|
inline |
Convenience operators to form a LinearProtoTask expr op rhs (or l <= expr <= u) where expr is a linear expression of the form matrixExpr * VariablePtr or an affine expression as a sum of linear expressions and vectorExpr.
- Parameters
-
lin the linear expression to form the task aff the affine expression to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you don't need to explicitly write a double (e.g 0.) to the contrary of the operators working with shared_ptr on Function.
◆ operator>=() [7/9]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator>=() [8/9]
|
inline |
Convenience operators to form a ProtoTask or LinearProtoTask f op rhs (or l <= f <= u)
- Parameters
-
f the function to form the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
◆ operator>=() [9/9]
|
inline |
Convenience operators to form a LinearProtoTask x op rhs (or l <= x <= u)
- Parameters
-
x the variable used in the task rhs a double or a Eigen::Vector with the same size as the function. Note that for a double you need to explicitly write a double (e.g 0., not 0), otherwise the compiler won't be able to decide which overload to pick between this and shared_ptr operator.
