Drake
drake::symbolic Namespace Reference

Namespaces

 detail
 
 internal
 
 test
 

Classes

class  BinaryExpressionCell
 Represents the base class for binary expressions. More...
 
class  Environment
 Represents a symbolic environment (mapping from a variable to a value). More...
 
class  Expression
 Represents a symbolic form of an expression. More...
 
class  ExpressionAbs
 Symbolic expression representing absolute value function. More...
 
class  ExpressionAcos
 Symbolic expression representing arccosine function. More...
 
class  ExpressionAdd
 Symbolic expression representing an addition which is a sum of products. More...
 
class  ExpressionAddFactory
 Factory class to help build ExpressionAdd expressions. More...
 
class  ExpressionAsin
 Symbolic expression representing arcsine function. More...
 
class  ExpressionAtan
 Symbolic expression representing arctangent function. More...
 
class  ExpressionAtan2
 Symbolic expression representing atan2 function (arctangent function with two arguments). More...
 
class  ExpressionCeiling
 Symbolic expression representing ceil function. More...
 
class  ExpressionCell
 Represents an abstract class which is the base of concrete symbolic-expression classes. More...
 
class  ExpressionConstant
 Symbolic expression representing a constant. More...
 
class  ExpressionCos
 Symbolic expression representing cosine function. More...
 
class  ExpressionCosh
 Symbolic expression representing hyperbolic cosine function. More...
 
class  ExpressionDiv
 Symbolic expression representing division. More...
 
class  ExpressionExp
 Symbolic expression representing exponentiation using the base of natural logarithms. More...
 
class  ExpressionFloor
 Symbolic expression representing floor function. More...
 
class  ExpressionIfThenElse
 Symbolic expression representing if-then-else expression. More...
 
class  ExpressionLog
 Symbolic expression representing logarithms. More...
 
class  ExpressionMax
 Symbolic expression representing max function. More...
 
class  ExpressionMin
 Symbolic expression representing min function. More...
 
class  ExpressionMul
 Symbolic expression representing a multiplication of powers. More...
 
class  ExpressionMulFactory
 Factory class to help build ExpressionMul expressions. More...
 
class  ExpressionNaN
 Symbolic expression representing NaN (not-a-number). More...
 
class  ExpressionPow
 Symbolic expression representing power function. More...
 
class  ExpressionSin
 Symbolic expression representing sine function. More...
 
class  ExpressionSinh
 Symbolic expression representing hyperbolic sine function. More...
 
class  ExpressionSqrt
 Symbolic expression representing square-root. More...
 
class  ExpressionTan
 Symbolic expression representing tangent function. More...
 
class  ExpressionTanh
 Symbolic expression representing hyperbolic tangent function. More...
 
class  ExpressionUninterpretedFunction
 Symbolic expression representing an uninterpreted function. More...
 
class  ExpressionVar
 Symbolic expression representing a variable. More...
 
class  Formula
 Represents a symbolic form of a first-order logic formula. More...
 
class  FormulaAnd
 Symbolic formula representing conjunctions (f1 ∧ ... More...
 
class  FormulaCell
 Represents an abstract class which is the base of concrete symbolic-formula classes (i.e. More...
 
class  FormulaEq
 Symbolic formula representing equality (e1 = e2). More...
 
class  FormulaFalse
 Symbolic formula representing false. More...
 
class  FormulaForall
 Symbolic formula representing universal quantifications (∀ x₁, ..., * xn. More...
 
class  FormulaGeq
 Symbolic formula representing 'greater-than-or-equal-to' (e1 ≥ e2). More...
 
class  FormulaGt
 Symbolic formula representing 'greater-than' (e1 > e2). More...
 
class  FormulaIsnan
 Symbolic formula representing isnan predicate. More...
 
class  FormulaLeq
 Symbolic formula representing 'less-than-or-equal-to' (e1 ≤ e2). More...
 
class  FormulaLt
 Symbolic formula representing 'less-than' (e1 < e2). More...
 
class  FormulaNeq
 Symbolic formula representing disequality (e1 ≠ e2). More...
 
class  FormulaNot
 Symbolic formula representing negations (¬f). More...
 
class  FormulaOr
 Symbolic formula representing disjunctions (f1 ∨ ... More...
 
class  FormulaPositiveSemidefinite
 Symbolic formula representing positive-semidefinite (PSD) constraint. More...
 
class  FormulaTrue
 Symbolic formula representing true. More...
 
class  FormulaVar
 Symbolic formula representing a Boolean variable. More...
 
struct  GradedReverseLexOrder
 Implements Graded reverse lexicographic order. More...
 
class  Monomial
 Represents a monomial, a product of powers of variables with non-negative integer exponents. More...
 
class  NaryFormulaCell
 Represents the base class for N-ary logic operators (∧ and ∨). More...
 
class  Polynomial
 Represents symbolic polynomials. More...
 
class  RelationalFormulaCell
 Represents the base class for relational operators (==, !=, <, <=, >, >=). More...
 
class  UnaryExpressionCell
 Represents the base class for unary expressions. More...
 
class  Variable
 Represents a symbolic variable. More...
 
class  Variables
 Represents a set of variables. More...
 

Typedefs

using Substitution = std::unordered_map< Variable, Expression, hash_value< Variable >>
 

Enumerations

enum  ExpressionKind {
  Constant, Var, Add, Mul,
  Div, Log, Abs, Exp,
  Sqrt, Pow, Sin, Cos,
  Tan, Asin, Acos, Atan,
  Atan2, Sinh, Cosh, Tanh,
  Min, Max, Ceil, Floor,
  IfThenElse, NaN, UninterpretedFunction
}
 Kinds of symbolic expressions. More...
 
enum  FormulaKind {
  False, True, Var, Eq,
  Neq, Gt, Geq, Lt,
  Leq, And, Or, Not,
  Forall, Isnan, PositiveSemidefinite
}
 Kinds of symbolic formulas. More...
 

Functions

ostream & operator<< (ostream &os, const Environment &env)
 
bool operator< (ExpressionKind k1, ExpressionKind k2)
 Total ordering between ExpressionKinds. More...
 
Expression operator+ (Expression lhs, const Expression &rhs)
 
Expressionoperator+= (Expression &lhs, const Expression &rhs)
 
Expression operator- (Expression lhs, const Expression &rhs)
 
Expressionoperator-= (Expression &lhs, const Expression &rhs)
 
Expression operator- (const Expression &e)
 
Expression operator* (Expression lhs, const Expression &rhs)
 
Expressionoperator*= (Expression &lhs, const Expression &rhs)
 
Expression operator/ (Expression lhs, const Expression &rhs)
 
Expressionoperator/= (Expression &lhs, const Expression &rhs)
 
ostream & operator<< (ostream &os, const Expression &e)
 
Expression log (const Expression &e)
 
Expression abs (const Expression &e)
 
Expression exp (const Expression &e)
 
Expression sqrt (const Expression &e)
 
Expression pow (const Expression &e1, const Expression &e2)
 
Expression sin (const Expression &e)
 
Expression cos (const Expression &e)
 
Expression tan (const Expression &e)
 
Expression asin (const Expression &e)
 
Expression acos (const Expression &e)
 
Expression atan (const Expression &e)
 
Expression atan2 (const Expression &e1, const Expression &e2)
 
Expression sinh (const Expression &e)
 
Expression cosh (const Expression &e)
 
Expression tanh (const Expression &e)
 
Expression min (const Expression &e1, const Expression &e2)
 
Expression max (const Expression &e1, const Expression &e2)
 
Expression ceil (const Expression &e)
 
Expression floor (const Expression &e)
 
Expression if_then_else (const Formula &f_cond, const Expression &e_then, const Expression &e_else)
 
Expression uninterpreted_function (const std::string &name, const Variables &vars)
 Constructs an uninterpreted-function expression with name and vars. More...
 
bool is_constant (const Expression &e)
 Checks if e is a constant expression. More...
 
bool is_constant (const Expression &e, double v)
 Checks if e is a constant expression representing v. More...
 
bool is_zero (const Expression &e)
 Checks if e is 0.0. More...
 
bool is_one (const Expression &e)
 Checks if e is 1.0. More...
 
bool is_neg_one (const Expression &e)
 Checks if e is -1.0. More...
 
bool is_two (const Expression &e)
 Checks if e is 2.0. More...
 
bool is_nan (const Expression &e)
 Checks if e is NaN. More...
 
bool is_variable (const Expression &e)
 Checks if e is a variable expression. More...
 
bool is_addition (const Expression &e)
 Checks if e is an addition expression. More...
 
bool is_multiplication (const Expression &e)
 Checks if e is a multiplication expression. More...
 
bool is_division (const Expression &e)
 Checks if e is a division expression. More...
 
bool is_log (const Expression &e)
 Checks if e is a log expression. More...
 
bool is_abs (const Expression &e)
 Checks if e is an abs expression. More...
 
bool is_exp (const Expression &e)
 Checks if e is an exp expression. More...
 
bool is_sqrt (const Expression &e)
 Checks if e is a square-root expression. More...
 
bool is_pow (const Expression &e)
 Checks if e is a power-function expression. More...
 
bool is_sin (const Expression &e)
 Checks if e is a sine expression. More...
 
bool is_cos (const Expression &e)
 Checks if e is a cosine expression. More...
 
bool is_tan (const Expression &e)
 Checks if e is a tangent expression. More...
 
bool is_asin (const Expression &e)
 Checks if e is an arcsine expression. More...
 
bool is_acos (const Expression &e)
 Checks if e is an arccosine expression. More...
 
bool is_atan (const Expression &e)
 Checks if e is an arctangent expression. More...
 
bool is_atan2 (const Expression &e)
 Checks if e is an arctangent2 expression. More...
 
bool is_sinh (const Expression &e)
 Checks if e is a hyperbolic-sine expression. More...
 
bool is_cosh (const Expression &e)
 Checks if e is a hyperbolic-cosine expression. More...
 
bool is_tanh (const Expression &e)
 Checks if e is a hyperbolic-tangent expression. More...
 
bool is_min (const Expression &e)
 Checks if e is a min expression. More...
 
bool is_max (const Expression &e)
 Checks if e is a max expression. More...
 
bool is_ceil (const Expression &e)
 
bool is_floor (const Expression &e)
 
bool is_if_then_else (const Expression &e)
 Checks if e is an if-then-else expression. More...
 
bool is_uninterpreted_function (const Expression &e)
 Checks if e is an uninterpreted-function expression. More...
 
double get_constant_value (const Expression &e)
 Returns the constant value of the constant expression e. More...
 
const Variableget_variable (const Expression &e)
 Returns the embedded variable in the variable expression e. More...
 
const Expressionget_argument (const Expression &e)
 Returns the argument in the unary expression e. More...
 
const Expressionget_first_argument (const Expression &e)
 Returns the first argument of the binary expression e. More...
 
const Expressionget_second_argument (const Expression &e)
 Returns the second argument of the binary expression e. More...
 
double get_constant_in_addition (const Expression &e)
 Returns the constant part of the addition expression e. More...
 
const map< Expression, double > & get_expr_to_coeff_map_in_addition (const Expression &e)
 Returns the map from an expression to its coefficient in the addition expression e. More...
 
double get_constant_in_multiplication (const Expression &e)
 Returns the constant part of the multiplication expression e. More...
 
const map< Expression, Expression > & get_base_to_exponent_map_in_multiplication (const Expression &e)
 Returns the map from a base expression to its exponent expression in the multiplication expression e. More...
 
const string & get_uninterpreted_function_name (const Expression &e)
 Returns the name of an uninterpreted-function expression e. More...
 
Expressionoperator+= (Expression &lhs, const Variable &rhs)
 
Expression operator+ (const Variable &lhs, const Variable &rhs)
 
Expression operator+ (Expression lhs, const Variable &rhs)
 
Expression operator+ (const Variable &lhs, Expression rhs)
 
Expressionoperator-= (Expression &lhs, const Variable &rhs)
 
Expression operator- (const Variable &lhs, const Variable &rhs)
 
Expression operator- (Expression lhs, const Variable &rhs)
 
Expression operator- (const Variable &lhs, const Expression &rhs)
 
Expressionoperator*= (Expression &lhs, const Variable &rhs)
 
Expression operator* (const Variable &lhs, const Variable &rhs)
 
Expression operator* (Expression lhs, const Variable &rhs)
 
Expression operator* (const Variable &lhs, Expression rhs)
 
Expressionoperator/= (Expression &lhs, const Variable &rhs)
 
Expression operator/ (const Variable &lhs, const Variable &rhs)
 
Expression operator/ (Expression lhs, const Variable &rhs)
 
Expression operator/ (const Variable &lhs, const Expression &rhs)
 
Expression operator+ (const Variable &var)
 
Expression operator- (const Variable &var)
 
MatrixX< ExpressionJacobian (const Eigen::Ref< const VectorX< Expression >> &f, const std::vector< Variable > &vars)
 Computes the Jacobian matrix J of the vector function f with respect to vars. More...
 
MatrixX< ExpressionJacobian (const Eigen::Ref< const VectorX< Expression >> &f, const Eigen::Ref< const VectorX< Variable >> &vars)
 Computes the Jacobian matrix J of the vector function f with respect to vars. More...
 
void swap (Expression &a, Expression &b)
 
template<typename MatrixL , typename MatrixR >
std::enable_if< std::is_base_of< Eigen::MatrixBase< MatrixL >, MatrixL >::value &&std::is_base_of< Eigen::MatrixBase< MatrixR >, MatrixR >::value &&std::is_same< typename MatrixL::Scalar, Expression >::value &&std::is_same< typename MatrixR::Scalar, double >::value, Eigen::Matrix< Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime > >::type operator* (const MatrixL &lhs, const MatrixR &rhs)
 Provides the following seven operations: More...
 
template<typename MatrixL , typename MatrixR >
std::enable_if< std::is_base_of< Eigen::MatrixBase< MatrixL >, MatrixL >::value &&std::is_base_of< Eigen::MatrixBase< MatrixR >, MatrixR >::value &&std::is_same< typename MatrixL::Scalar, double >::value &&std::is_same< typename MatrixR::Scalar, Expression >::value, Eigen::Matrix< Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime > >::type operator* (const MatrixL &lhs, const MatrixR &rhs)
 Provides the following seven operations: More...
 
template<typename MatrixL , typename MatrixR >
std::enable_if< std::is_base_of< Eigen::MatrixBase< MatrixL >, MatrixL >::value &&std::is_base_of< Eigen::MatrixBase< MatrixR >, MatrixR >::value &&std::is_same< typename MatrixL::Scalar, Expression >::value &&std::is_same< typename MatrixR::Scalar, Variable >::value, Eigen::Matrix< Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime > >::type operator* (const MatrixL &lhs, const MatrixR &rhs)
 Provides the following seven operations: More...
 
template<typename MatrixL , typename MatrixR >
std::enable_if< std::is_base_of< Eigen::MatrixBase< MatrixL >, MatrixL >::value &&std::is_base_of< Eigen::MatrixBase< MatrixR >, MatrixR >::value &&std::is_same< typename MatrixL::Scalar, Variable >::value &&std::is_same< typename MatrixR::Scalar, Expression >::value, Eigen::Matrix< Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime > >::type operator* (const MatrixL &lhs, const MatrixR &rhs)
 Provides the following seven operations: More...
 
template<typename MatrixL , typename MatrixR >
std::enable_if< std::is_base_of< Eigen::MatrixBase< MatrixL >, MatrixL >::value &&std::is_base_of< Eigen::MatrixBase< MatrixR >, MatrixR >::value &&std::is_same< typename MatrixL::Scalar, Variable >::value &&std::is_same< typename MatrixR::Scalar, double >::value, Eigen::Matrix< Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime > >::type operator* (const MatrixL &lhs, const MatrixR &rhs)
 Provides the following seven operations: More...
 
template<typename MatrixL , typename MatrixR >
std::enable_if< std::is_base_of< Eigen::MatrixBase< MatrixL >, MatrixL >::value &&std::is_base_of< Eigen::MatrixBase< MatrixR >, MatrixR >::value &&std::is_same< typename MatrixL::Scalar, double >::value &&std::is_same< typename MatrixR::Scalar, Variable >::value, Eigen::Matrix< Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime > >::type operator* (const MatrixL &lhs, const MatrixR &rhs)
 Provides the following seven operations: More...
 
template<int Dim, int LhsMode, int RhsMode, int LhsOptions, int RhsOptions>
auto operator* (const Eigen::Transform< Expression, Dim, LhsMode, LhsOptions > &t1, const Eigen::Transform< double, Dim, RhsMode, RhsOptions > &t2)
 Transform<double> * Transform<Expression> => Transform<Expression> More...
 
template<int Dim, int LhsMode, int RhsMode, int LhsOptions, int RhsOptions>
auto operator* (const Eigen::Transform< double, Dim, LhsMode, LhsOptions > &t1, const Eigen::Transform< Expression, Dim, RhsMode, RhsOptions > &t2)
 Transform<Expression> * Transform<double> => Transform<Expression> More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_base_of< Eigen::MatrixBase< DerivedA >, DerivedA >::value &&std::is_base_of< Eigen::MatrixBase< DerivedB >, DerivedB >::value &&std::is_same< typename DerivedA::Scalar, Expression >::value &&std::is_same< typename DerivedB::Scalar, Expression >::value, bool >::type CheckStructuralEquality (const DerivedA &m1, const DerivedB &m2)
 Checks if two Eigen::Matrix<Expression> m1 and m2 are structurally equal. More...
 
Expression DifferentiatePow (const Expression &f, const Expression &g, const Variable &x)
 
bool is_constant (const ExpressionCell &c)
 Checks if c is a constant expression. More...
 
bool is_variable (const ExpressionCell &c)
 Checks if c is a variable expression. More...
 
bool is_addition (const ExpressionCell &c)
 Checks if c is an addition expression. More...
 
bool is_multiplication (const ExpressionCell &c)
 Checks if c is an multiplication expression. More...
 
bool is_division (const ExpressionCell &c)
 Checks if c is a division expression. More...
 
bool is_log (const ExpressionCell &c)
 Checks if c is a log expression. More...
 
bool is_abs (const ExpressionCell &c)
 Checks if c is an absolute-value-function expression. More...
 
bool is_exp (const ExpressionCell &c)
 Checks if c is an exp expression. More...
 
bool is_sqrt (const ExpressionCell &c)
 Checks if c is a square-root expression. More...
 
bool is_pow (const ExpressionCell &c)
 Checks if c is a power-function expression. More...
 
bool is_sin (const ExpressionCell &c)
 Checks if c is a sine expression. More...
 
bool is_cos (const ExpressionCell &c)
 Checks if c is a cosine expression. More...
 
bool is_tan (const ExpressionCell &c)
 Checks if c is a tangent expression. More...
 
bool is_asin (const ExpressionCell &c)
 Checks if c is an arcsine expression. More...
 
bool is_acos (const ExpressionCell &c)
 Checks if c is an arccosine expression. More...
 
bool is_atan (const ExpressionCell &c)
 Checks if c is an arctangent expression. More...
 
bool is_atan2 (const ExpressionCell &c)
 Checks if c is a arctangent2 expression. More...
 
bool is_sinh (const ExpressionCell &c)
 Checks if c is a hyperbolic-sine expression. More...
 
bool is_cosh (const ExpressionCell &c)
 Checks if c is a hyperbolic-cosine expression. More...
 
bool is_tanh (const ExpressionCell &c)
 Checks if c is a hyperbolic-tangent expression. More...
 
bool is_min (const ExpressionCell &c)
 Checks if c is a min expression. More...
 
bool is_max (const ExpressionCell &c)
 Checks if c is a max expression. More...
 
bool is_ceil (const ExpressionCell &c)
 Checks if c is a ceil expression. More...
 
bool is_floor (const ExpressionCell &c)
 Checks if c is a floor expression. More...
 
bool is_if_then_else (const ExpressionCell &c)
 Checks if c is an if-then-else expression. More...
 
bool is_uninterpreted_function (const ExpressionCell &c)
 Checks if c is an uninterpreted-function expression. More...
 
shared_ptr< ExpressionConstantto_constant (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionConstantto_constant (const Expression &e)
 Casts e to shared_ptr<ExpressionConstant>. More...
 
shared_ptr< ExpressionVarto_variable (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionVarto_variable (const Expression &e)
 Casts e to shared_ptr<ExpressionVar>. More...
 
shared_ptr< UnaryExpressionCellto_unary (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< UnaryExpressionCellto_unary (const Expression &e)
 Casts e to shared_ptr<UnaryExpressionCell>. More...
 
shared_ptr< BinaryExpressionCellto_binary (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< BinaryExpressionCellto_binary (const Expression &e)
 Casts e to shared_ptr<BinaryExpressionCell>. More...
 
shared_ptr< ExpressionAddto_addition (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionAddto_addition (const Expression &e)
 Casts e to shared_ptr<ExpressionAdd>. More...
 
shared_ptr< ExpressionMulto_multiplication (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionMulto_multiplication (const Expression &e)
 Casts e to shared_ptr<ExpressionMul>. More...
 
shared_ptr< ExpressionDivto_division (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionDivto_division (const Expression &e)
 Casts e to shared_ptr<ExpressionDiv>. More...
 
shared_ptr< ExpressionLogto_log (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionLogto_log (const Expression &e)
 Casts e to shared_ptr<ExpressionLog>. More...
 
shared_ptr< ExpressionAbsto_abs (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionAbsto_abs (const Expression &e)
 Casts e to shared_ptr<ExpressionAbs>. More...
 
shared_ptr< ExpressionExpto_exp (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionExpto_exp (const Expression &e)
 Casts e to shared_ptr<ExpressionExp>. More...
 
shared_ptr< ExpressionSqrtto_sqrt (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionSqrtto_sqrt (const Expression &e)
 Casts e to shared_ptr<ExpressionSqrt>. More...
 
shared_ptr< ExpressionPowto_pow (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionPowto_pow (const Expression &e)
 Casts e to shared_ptr<ExpressionPow>. More...
 
shared_ptr< ExpressionSinto_sin (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionSinto_sin (const Expression &e)
 Casts e to shared_ptr<ExpressionSin>. More...
 
shared_ptr< ExpressionCosto_cos (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionCosto_cos (const Expression &e)
 Casts e to shared_ptr<ExpressionCos>. More...
 
shared_ptr< ExpressionTanto_tan (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionTanto_tan (const Expression &e)
 Casts e to shared_ptr<ExpressionTan>. More...
 
shared_ptr< ExpressionAsinto_asin (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionAsinto_asin (const Expression &e)
 Casts e to shared_ptr<ExpressionAsin>. More...
 
shared_ptr< ExpressionAcosto_acos (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionAcosto_acos (const Expression &e)
 Casts e to shared_ptr<ExpressionAcos>. More...
 
shared_ptr< ExpressionAtanto_atan (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionAtanto_atan (const Expression &e)
 Casts e to shared_ptr<ExpressionAtan>. More...
 
shared_ptr< ExpressionAtan2to_atan2 (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionAtan2to_atan2 (const Expression &e)
 Casts e to shared_ptr<ExpressionAtan2>. More...
 
shared_ptr< ExpressionSinhto_sinh (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionSinhto_sinh (const Expression &e)
 Casts e to shared_ptr<ExpressionSinh>. More...
 
shared_ptr< ExpressionCoshto_cosh (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionCoshto_cosh (const Expression &e)
 Casts e to shared_ptr<ExpressionCosh>. More...
 
shared_ptr< ExpressionTanhto_tanh (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionTanhto_tanh (const Expression &e)
 Casts e to shared_ptr<ExpressionTanh>. More...
 
shared_ptr< ExpressionMinto_min (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionMinto_min (const Expression &e)
 Casts e to shared_ptr<ExpressionMin>. More...
 
shared_ptr< ExpressionMaxto_max (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionMaxto_max (const Expression &e)
 Casts e to shared_ptr<ExpressionMax>. More...
 
shared_ptr< ExpressionCeilingto_ceil (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionCeilingto_ceil (const Expression &e)
 Casts e to shared_ptr<ExpressionCeiling>. More...
 
shared_ptr< ExpressionFloorto_floor (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionFloorto_floor (const Expression &e)
 Casts e to shared_ptr<ExpressionFloor>. More...
 
shared_ptr< ExpressionIfThenElseto_if_then_else (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionIfThenElseto_if_then_else (const Expression &e)
 Casts e to shared_ptr<ExpressionIfThenElse>. More...
 
shared_ptr< ExpressionUninterpretedFunctionto_uninterpreted_function (const shared_ptr< ExpressionCell > &expr_ptr)
 
shared_ptr< ExpressionUninterpretedFunctionto_uninterpreted_function (const Expression &e)
 Casts e to shared_ptr<ExpressionUninterpretedFunction>. More...
 
std::shared_ptr< ExpressionConstantto_constant (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionConstant>. More...
 
std::shared_ptr< ExpressionVarto_variable (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionVar>. More...
 
std::shared_ptr< UnaryExpressionCellto_unary (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<UnaryExpressionCell>. More...
 
std::shared_ptr< BinaryExpressionCellto_binary (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<BinaryExpressionCell>. More...
 
std::shared_ptr< ExpressionAddto_addition (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionAdd>. More...
 
std::shared_ptr< ExpressionMulto_multiplication (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionMul>. More...
 
std::shared_ptr< ExpressionDivto_division (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionDiv>. More...
 
std::shared_ptr< ExpressionLogto_log (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionLog>. More...
 
std::shared_ptr< ExpressionExpto_exp (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionExp>. More...
 
std::shared_ptr< ExpressionAbsto_abs (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionAbs>. More...
 
std::shared_ptr< ExpressionSqrtto_sqrt (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionSqrt>. More...
 
std::shared_ptr< ExpressionPowto_pow (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionPow>. More...
 
std::shared_ptr< ExpressionSinto_sin (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionSin>. More...
 
std::shared_ptr< ExpressionCosto_cos (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionCos>. More...
 
std::shared_ptr< ExpressionTanto_tan (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionTan>. More...
 
std::shared_ptr< ExpressionAsinto_asin (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionAsin>. More...
 
std::shared_ptr< ExpressionAcosto_acos (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionAcos>. More...
 
std::shared_ptr< ExpressionAtanto_atan (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionAtan>. More...
 
std::shared_ptr< ExpressionAtan2to_atan2 (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionAtan2>. More...
 
std::shared_ptr< ExpressionSinhto_sinh (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionSinh>. More...
 
std::shared_ptr< ExpressionCoshto_cosh (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionCosh>. More...
 
std::shared_ptr< ExpressionTanhto_tanh (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionTanh>. More...
 
std::shared_ptr< ExpressionMinto_min (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionMin>. More...
 
std::shared_ptr< ExpressionMaxto_max (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionMax>. More...
 
std::shared_ptr< ExpressionCeilingto_ceil (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionCeiling>. More...
 
std::shared_ptr< ExpressionFloorto_floor (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionFloor>. More...
 
std::shared_ptr< ExpressionIfThenElseto_if_then_else (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionIfThenElse>. More...
 
std::shared_ptr< ExpressionUninterpretedFunctionto_uninterpreted_function (const std::shared_ptr< ExpressionCell > &expr_ptr)
 Casts expr_ptr to shared_ptr<ExpressionUninterpretedFunction>. More...
 
template<typename Result , typename Visitor , typename... Args>
Result VisitPolynomial (Visitor *v, const Expression &e, Args &&...args)
 Calls visitor object v with a polynomial symbolic-expression e, and arguments args. More...
 
template<typename Result , typename Visitor , typename... Args>
Result VisitExpression (Visitor *v, const Expression &e, Args &&...args)
 Calls visitor object v with a symbolic-expression e, and arguments args. More...
 
bool operator< (FormulaKind k1, FormulaKind k2)
 
Formula forall (const Variables &vars, const Formula &f)
 Returns a formula f, universally quantified by variables vars. More...
 
Formula make_conjunction (const std::set< Formula > &formulas)
 Returns a conjunction of formulas. More...
 
Formula operator&& (const Formula &f1, const Formula &f2)
 
Formula operator&& (const Variable &v, const Formula &f)
 
Formula operator&& (const Formula &f, const Variable &v)
 
Formula operator&& (const Variable &v1, const Variable &v2)
 
Formula make_disjunction (const std::set< Formula > &formulas)
 Returns a disjunction of formulas. More...
 
Formula operator|| (const Formula &f1, const Formula &f2)
 
Formula operator|| (const Variable &v, const Formula &f)
 
Formula operator|| (const Formula &f, const Variable &v)
 
Formula operator|| (const Variable &v1, const Variable &v2)
 
Formula operator! (const Formula &f)
 
Formula operator! (const Variable &v)
 
ostream & operator<< (ostream &os, const Formula &f)
 
Formula operator== (const Expression &e1, const Expression &e2)
 
Formula operator!= (const Expression &e1, const Expression &e2)
 
Formula operator< (const Expression &e1, const Expression &e2)
 
Formula operator<= (const Expression &e1, const Expression &e2)
 
Formula operator> (const Expression &e1, const Expression &e2)
 
Formula operator>= (const Expression &e1, const Expression &e2)
 
Formula isnan (const Expression &e)
 Returns a Formula for the predicate isnan(e) to the given expression. More...
 
Formula positive_semidefinite (const Eigen::Ref< const MatrixX< Expression >> &m)
 Returns a symbolic formula constraining m to be a positive-semidefinite matrix. More...
 
Formula positive_semidefinite (const MatrixX< Expression > &m, Eigen::UpLoType mode)
 Constructs and returns a symbolic positive-semidefinite formula from m. More...
 
bool is_false (const Formula &f)
 Checks if f is structurally equal to False formula. More...
 
bool is_true (const Formula &f)
 Checks if f is structurally equal to True formula. More...
 
bool is_variable (const Formula &f)
 Checks if f is a variable formula. More...
 
bool is_equal_to (const Formula &f)
 Checks if f is a formula representing equality (==). More...
 
bool is_not_equal_to (const Formula &f)
 Checks if f is a formula representing disequality (!=). More...
 
bool is_greater_than (const Formula &f)
 Checks if f is a formula representing greater-than (>). More...
 
bool is_greater_than_or_equal_to (const Formula &f)
 Checks if f is a formula representing greater-than-or-equal-to (>=). More...
 
bool is_less_than (const Formula &f)
 Checks if f is a formula representing less-than (<). More...
 
bool is_less_than_or_equal_to (const Formula &f)
 Checks if f is a formula representing less-than-or-equal-to (<=). More...
 
bool is_relational (const Formula &f)
 Checks if f is a relational formula ({==, !=, >, >=, <, <=}). More...
 
bool is_conjunction (const Formula &f)
 Checks if f is a conjunction (∧). More...
 
bool is_disjunction (const Formula &f)
 Checks if f is a disjunction (∨). More...
 
bool is_nary (const Formula &f)
 Checks if f is a n-ary formula ({∧, ∨}). More...
 
bool is_negation (const Formula &f)
 Checks if f is a negation (¬). More...
 
bool is_forall (const Formula &f)
 Checks if f is a Forall formula (∀). More...
 
bool is_isnan (const Formula &f)
 Checks if f is an isnan formula. More...
 
bool is_positive_semidefinite (const Formula &f)
 Checks if f is a positive-semidefinite formula. More...
 
const Variableget_variable (const Formula &f)
 Returns the embedded variable in the variable formula f. More...
 
const Expressionget_lhs_expression (const Formula &f)
 Returns the lhs-argument of a relational formula f. More...
 
const Expressionget_rhs_expression (const Formula &f)
 Returns the rhs-argument of a relational formula f. More...
 
const set< Formula > & get_operands (const Formula &f)
 Returns the set of formulas in a n-ary formula f. More...
 
const Formulaget_operand (const Formula &f)
 Returns the formula in a negation formula f. More...
 
const Variablesget_quantified_variables (const Formula &f)
 Returns the quantified variables in a forall formula f. More...
 
const Formulaget_quantified_formula (const Formula &f)
 Returns the quantified formula in a forall formula f. More...
 
const MatrixX< Expression > & get_matrix_in_positive_semidefinite (const Formula &f)
 Returns the matrix in a positive-semidefinite formula f. More...
 
template<typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Derived::Scalar, Expression >::value, Formula >::type positive_semidefinite (const Eigen::TriangularView< Derived, Eigen::Lower > &l)
 Constructs and returns a symbolic positive-semidefinite formula from a lower triangular-view l. More...
 
template<typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Derived::Scalar, Expression >::value, Formula >::type positive_semidefinite (const Eigen::TriangularView< Derived, Eigen::Upper > &u)
 Constructs and returns a symbolic positive-semidefinite formula from an upper triangular-view u. More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()==typename DerivedB::Scalar()), Formula >::value, typename detail::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >::type operator== (const DerivedA &a1, const DerivedB &a2)
 Returns an Eigen array of symbolic formulas where each element includes element-wise symbolic-equality of two arrays m1 and m2. More...
 
template<typename Derived , typename ScalarType >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename Derived::Scalar()==ScalarType()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator== (const Derived &a, const ScalarType &v)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between an array a and a scalar v using equal-to operator (==). More...
 
template<typename ScalarType , typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(ScalarType()==typename Derived::Scalar()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator== (const ScalarType &v, const Derived &a)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between a scalar v and an array using equal-to operator (==). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()<=typename DerivedB::Scalar()), Formula >::value, typename detail::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >::type operator<= (const DerivedA &a1, const DerivedB &a2)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison of two arrays a1 and a2 using less-than-or-equal operator (<=). More...
 
template<typename Derived , typename ScalarType >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename Derived::Scalar()<=ScalarType()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator<= (const Derived &a, const ScalarType &v)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between an array a and a scalar v using less-than-or-equal operator (<=). More...
 
template<typename ScalarType , typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(ScalarType()<=typename Derived::Scalar()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator<= (const ScalarType &v, const Derived &a)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between a scalar v and an array using less-than-or-equal operator (<=). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()< typename DerivedB::Scalar()), Formula >::value, typename detail::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >::type operator< (const DerivedA &a1, const DerivedB &a2)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison of two arrays a1 and a2 using less-than operator (<). More...
 
template<typename Derived , typename ScalarType >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename Derived::Scalar()< ScalarType()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator< (const Derived &a, const ScalarType &v)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between an array a and a scalar v using less-than operator (<). More...
 
template<typename ScalarType , typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(ScalarType()< typename Derived::Scalar()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator< (const ScalarType &v, const Derived &a)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between a scalar v and an array using less-than operator (<). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar() >=typename DerivedB::Scalar()), Formula >::value, typename detail::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >::type operator>= (const DerivedA &a1, const DerivedB &a2)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison of two arrays a1 and a2 using greater-than-or-equal operator (>=). More...
 
template<typename Derived , typename ScalarType >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename Derived::Scalar() >=ScalarType()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator>= (const Derived &a, const ScalarType &v)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between an array a and a scalar v using greater-than-or-equal operator (>=). More...
 
template<typename ScalarType , typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(ScalarType() >=typename Derived::Scalar()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator>= (const ScalarType &v, const Derived &a)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between a scalar v and an array using less-than-or-equal operator (<=) instead of greater-than-or-equal operator (>=). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar() > typename DerivedB::Scalar()), Formula >::value, typename detail::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >::type operator> (const DerivedA &a1, const DerivedB &a2)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison of two arrays a1 and a2 using greater-than operator (>). More...
 
template<typename Derived , typename ScalarType >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename Derived::Scalar() > ScalarType()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator> (const Derived &a, const ScalarType &v)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between an array a and a scalar v using greater-than operator (>). More...
 
template<typename ScalarType , typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(ScalarType() > typename Derived::Scalar()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator> (const ScalarType &v, const Derived &a)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between a scalar v and an array using less-than operator (<) instead of greater-than operator (>). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()!=typename DerivedB::Scalar()), Formula >::value, typename detail::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >::type operator!= (const DerivedA &a1, const DerivedB &a2)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison of two arrays a1 and a2 using not-equal operator (!=). More...
 
template<typename Derived , typename ScalarType >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(typename Derived::Scalar()!=ScalarType()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator!= (const Derived &a, const ScalarType &v)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between an array a and a scalar v using not-equal operator (!=). More...
 
template<typename ScalarType , typename Derived >
std::enable_if< std::is_same< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr >::value &&std::is_same< decltype(ScalarType()!=typename Derived::Scalar()), Formula >::value, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >::type operator!= (const ScalarType &v, const Derived &a)
 Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between a scalar v and an array using not-equal operator (!=). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()==typename DerivedB::Scalar()), Formula >::value, Formula >::type operator== (const DerivedA &m1, const DerivedB &m2)
 Returns a symbolic formula checking if two matrices m1 and m2 are equal. More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()!=typename DerivedB::Scalar()), Formula >::value, Formula >::type operator!= (const DerivedA &m1, const DerivedB &m2)
 Returns a symbolic formula representing element-wise comparison between two matrices m1 and m2 using not-equal (!=) operator. More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()< typename DerivedB::Scalar()), Formula >::value, Formula >::type operator< (const DerivedA &m1, const DerivedB &m2)
 Returns a symbolic formula representing element-wise comparison between two matrices m1 and m2 using less-than (<) operator. More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar()<=typename DerivedB::Scalar()), Formula >::value, Formula >::type operator<= (const DerivedA &m1, const DerivedB &m2)
 Returns a symbolic formula representing element-wise comparison between two matrices m1 and m2 using less-than-or-equal operator (<=). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar() > typename DerivedB::Scalar()), Formula >::value, Formula >::type operator> (const DerivedA &m1, const DerivedB &m2)
 Returns a symbolic formula representing element-wise comparison between two matrices m1 and m2 using greater-than operator (>). More...
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_same< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr >::value &&std::is_same< decltype(typename DerivedA::Scalar() >=typename DerivedB::Scalar()), Formula >::value, Formula >::type operator>= (const DerivedA &m1, const DerivedB &m2)
 Returns a symbolic formula representing element-wise comparison between two matrices m1 and m2 using greater-than-or-equal operator (>=). More...
 
bool is_false (const FormulaCell &f)
 Checks if f is structurally equal to False formula. More...
 
bool is_true (const FormulaCell &f)
 Checks if f is structurally equal to True formula. More...
 
bool is_variable (const FormulaCell &f)
 Checks if f is a variable formula. More...
 
bool is_equal_to (const FormulaCell &f)
 Checks if f is a formula representing equality (==). More...
 
bool is_not_equal_to (const FormulaCell &f)
 Checks if f is a formula representing disequality (!=). More...
 
bool is_greater_than (const FormulaCell &f)
 Checks if f is a formula representing greater-than (>). More...
 
bool is_greater_than_or_equal_to (const FormulaCell &f)
 Checks if f is a formula representing greater-than-or-equal-to (>=). More...
 
bool is_less_than (const FormulaCell &f)
 Checks if f is a formula representing less-than (<). More...
 
bool is_less_than_or_equal_to (const FormulaCell &f)
 Checks if f is a formula representing less-than-or-equal-to (<=). More...
 
bool is_relational (const FormulaCell &f)
 Checks if f is a relational formula ({==, !=, >, >=, <, <=}). More...
 
bool is_conjunction (const FormulaCell &f)
 Checks if f is a conjunction (∧). More...
 
bool is_disjunction (const FormulaCell &f)
 Checks if f is a disjunction (∨). More...
 
bool is_nary (const FormulaCell &f)
 
bool is_negation (const FormulaCell &f)
 Checks if f is a negation (¬). More...
 
bool is_forall (const FormulaCell &f)
 Checks if f is a Forall formula (∀). More...
 
bool is_isnan (const FormulaCell &f)
 Checks if f is an isnan formula. More...
 
bool is_positive_semidefinite (const FormulaCell &f)
 Checks if f is a positive semidefinite formula. More...
 
shared_ptr< FormulaFalseto_false (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaFalseto_false (const Formula &f)
 Casts f to shared_ptr<FormulaFalse>. More...
 
shared_ptr< FormulaTrueto_true (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaTrueto_true (const Formula &f)
 Casts f to shared_ptr<FormulaTrue>. More...
 
shared_ptr< FormulaVarto_variable (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaVarto_variable (const Formula &f)
 Casts f to shared_ptr<FormulaVar>. More...
 
shared_ptr< RelationalFormulaCellto_relational (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< RelationalFormulaCellto_relational (const Formula &f)
 Casts f to shared_ptr<RelationalFormulaCell>. More...
 
shared_ptr< FormulaEqto_equal_to (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaEqto_equal_to (const Formula &f)
 Casts f to shared_ptr<FormulaEq>. More...
 
shared_ptr< FormulaNeqto_not_equal_to (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaNeqto_not_equal_to (const Formula &f)
 Casts f to shared_ptr<FormulaNeq>. More...
 
shared_ptr< FormulaGtto_greater_than (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaGtto_greater_than (const Formula &f)
 Casts f to shared_ptr<FormulaGt>. More...
 
shared_ptr< FormulaGeqto_greater_than_or_equal_to (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaGeqto_greater_than_or_equal_to (const Formula &f)
 Casts f to shared_ptr<FormulaGeq>. More...
 
shared_ptr< FormulaLtto_less_than (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaLtto_less_than (const Formula &f)
 Casts f to shared_ptr<FormulaLt>. More...
 
shared_ptr< FormulaLeqto_less_than_or_equal_to (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaLeqto_less_than_or_equal_to (const Formula &f)
 Casts f to shared_ptr<FormulaLeq>. More...
 
shared_ptr< NaryFormulaCellto_nary (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< NaryFormulaCellto_nary (const Formula &f)
 Casts f to shared_ptr<NaryFormulaCell>. More...
 
shared_ptr< FormulaAndto_conjunction (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaAndto_conjunction (const Formula &f)
 Casts f to shared_ptr<FormulaAnd>. More...
 
shared_ptr< FormulaOrto_disjunction (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaOrto_disjunction (const Formula &f)
 Casts f to shared_ptr<FormulaOr>. More...
 
shared_ptr< FormulaNotto_negation (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaNotto_negation (const Formula &f)
 Casts f to shared_ptr<FormulaNot>. More...
 
shared_ptr< FormulaForallto_forall (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaForallto_forall (const Formula &f)
 Casts f to shared_ptr<FormulaForall>. More...
 
shared_ptr< FormulaIsnanto_isnan (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaIsnanto_isnan (const Formula &f)
 Casts f to shared_ptr<FormulaIsnan>. More...
 
shared_ptr< FormulaPositiveSemidefiniteto_positive_semidefinite (const shared_ptr< FormulaCell > &f_ptr)
 
shared_ptr< FormulaPositiveSemidefiniteto_positive_semidefinite (const Formula &f)
 Casts f to shared_ptr<FormulaPositiveSemidefinite>. More...
 
std::shared_ptr< FormulaFalseto_false (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaFalse>. More...
 
std::shared_ptr< FormulaTrueto_true (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaTrue>. More...
 
std::shared_ptr< FormulaVarto_variable (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaVar>. More...
 
std::shared_ptr< RelationalFormulaCellto_relational (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<RelationalFormulaCell>. More...
 
std::shared_ptr< FormulaEqto_equal_to (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaEq>. More...
 
std::shared_ptr< FormulaNeqto_not_equal_to (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaNeq>. More...
 
std::shared_ptr< FormulaGtto_greater_than (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaGt>. More...
 
std::shared_ptr< FormulaGeqto_greater_than_or_equal_to (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaGeq>. More...
 
std::shared_ptr< FormulaLtto_less_than (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaLt>. More...
 
std::shared_ptr< FormulaLeqto_less_than_or_equal_to (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaLeq>. More...
 
std::shared_ptr< FormulaAndto_conjunction (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaAnd>. More...
 
std::shared_ptr< FormulaOrto_disjunction (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaOr>. More...
 
std::shared_ptr< NaryFormulaCellto_nary (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<NaryFormulaCell>. More...
 
std::shared_ptr< FormulaNotto_negation (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaNot>. More...
 
std::shared_ptr< FormulaForallto_forall (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaForall>. More...
 
std::shared_ptr< FormulaIsnanto_isnan (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaIsnan>. More...
 
std::shared_ptr< FormulaPositiveSemidefiniteto_positive_semidefinite (const std::shared_ptr< FormulaCell > &f_ptr)
 Casts f_ptr to shared_ptr<FormulaPositiveSemidefinite>. More...
 
template<typename Result , typename Visitor , typename... Args>
Result VisitFormula (Visitor *v, const Formula &f, Args &&...args)
 Calls visitor object v with a symbolic formula f, and arguments args. More...
 
ostream & operator<< (ostream &out, const Monomial &m)
 
Monomial operator* (Monomial m1, const Monomial &m2)
 Returns a multiplication of two monomials, m1 and m2. More...
 
Monomial pow (Monomial m, int p)
 Returns m1 raised to p. More...
 
Eigen::Matrix< Monomial, Eigen::Dynamic, 1 > MonomialBasis (const Variables &vars, int degree)
 Returns all monomials up to a given degree under the graded reverse lexicographic order. More...
 
constexpr int NChooseK (int n, int k)
 
template<int n, int degree>
Eigen::Matrix< Monomial, NChooseK(n+degree, degree), 1 > MonomialBasis (const Variables &vars)
 Returns all monomials up to a given degree under the graded reverse lexicographic order. More...
 
Polynomial operator- (Polynomial p)
 Unary minus operation for polynomial. More...
 
Polynomial operator+ (Polynomial p1, const Polynomial &p2)
 
Polynomial operator+ (Polynomial p, const Monomial &m)
 
Polynomial operator+ (const Monomial &m, Polynomial p)
 
Polynomial operator+ (const Monomial &m1, const Monomial &m2)
 
Polynomial operator+ (Polynomial p, const double c)
 
Polynomial operator+ (const double c, Polynomial p)
 
Polynomial operator+ (const Monomial &m, const double c)
 
Polynomial operator+ (const double c, const Monomial &m)
 
Polynomial operator- (Polynomial p1, const Polynomial &p2)
 
Polynomial operator- (Polynomial p, const Monomial &m)
 
Polynomial operator- (const Monomial &m, Polynomial p)
 
Polynomial operator- (const Monomial &m1, const Monomial &m2)
 
Polynomial operator- (Polynomial p, const double c)
 
Polynomial operator- (const double c, Polynomial p)
 
Polynomial operator- (const Monomial &m, const double c)
 
Polynomial operator- (const double c, const Monomial &m)
 
Polynomial operator* (Polynomial p1, const Polynomial &p2)
 
Polynomial operator* (Polynomial p, const Monomial &m)
 
Polynomial operator* (const Monomial &m, Polynomial p)
 
Polynomial operator* (const double c, Polynomial p)
 
Polynomial operator* (Polynomial p, const double c)
 
Polynomial operator* (const Monomial &m, double c)
 
Polynomial operator* (double c, const Monomial &m)
 
Polynomial pow (const Polynomial &p, int n)
 Returns polynomial rasied to n. More...
 
ostream & operator<< (ostream &os, const Polynomial &p)
 
template<typename MatrixL , typename MatrixR >
Eigen::Matrix< Polynomial, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime > operator* (const MatrixL &lhs, const MatrixR &rhs)
 Provides the following seven operations: More...
 
ostream & operator<< (ostream &os, const Variable &var)
 
ostream & operator<< (ostream &os, Variable::Type type)
 
template<typename DerivedA , typename DerivedB >
std::enable_if< std::is_base_of< Eigen::MatrixBase< DerivedA >, DerivedA >::value &&std::is_base_of< Eigen::MatrixBase< DerivedB >, DerivedB >::value &&std::is_same< typename DerivedA::Scalar, Variable >::value &&std::is_same< typename DerivedB::Scalar, Variable >::value, bool >::type CheckStructuralEquality (const DerivedA &m1, const DerivedB &m2)
 Checks if two Eigen::Matrix<Variable> m1 and m2 are structurally equal. More...
 
bool operator== (const Variables &vars1, const Variables &vars2)
 
bool operator< (const Variables &vars1, const Variables &vars2)
 
Variables operator+= (Variables &vars1, const Variables &vars2)
 Updates var1 with the result of set-union(var1, var2). More...
 
Variables operator+= (Variables &vars, const Variable &var)
 Updates vars with the result of set-union(vars, { var }). More...
 
Variables operator+ (Variables vars1, const Variables &vars2)
 Returns set-union of var1 and var2. More...
 
Variables operator+ (Variables vars, const Variable &var)
 Returns set-union of vars and {var}. More...
 
Variables operator+ (const Variable &var, Variables vars)
 Returns set-union of {var} and vars. More...
 
Variables operator-= (Variables &vars1, const Variables &vars2)
 Updates var1 with the result of set-minus(var1, var2). More...
 
Variables operator-= (Variables &vars, const Variable &var)
 Updates vars with the result of set-minus(vars, {var}). More...
 
Variables operator- (Variables vars1, const Variables &vars2)
 Returns set-minus(var1, vars2). More...
 
Variables operator- (Variables vars, const Variable &var)
 Returns set-minus(vars, { var }). More...
 
Variables intersect (const Variables &vars1, const Variables &vars2)
 Returns the intersection of vars1 and vars2. More...
 
ostream & operator<< (ostream &os, const Variables &vars)
 

Typedef Documentation

using Substitution = std::unordered_map<Variable, Expression, hash_value<Variable>>

Enumeration Type Documentation

enum ExpressionKind
strong

Kinds of symbolic expressions.

Enumerator
Constant 

constant (double)

Var 

variable

Add 

addition (+)

Mul 

multiplication (*)

Div 

division (/)

Log 

logarithms

Abs 

absolute value function

Exp 

exponentiation

Sqrt 

square root

Pow 

power function

Sin 

sine

Cos 

cosine

Tan 

tangent

Asin 

arcsine

Acos 

arccosine

Atan 

arctangent

Atan2 

arctangent2 (atan2(y,x) = atan(y/x))

Sinh 

hyperbolic sine

Cosh 

hyperbolic cosine

Tanh 

hyperbolic tangent

Min 

min

Max 

max

Ceil 

ceil

Floor 

floor

IfThenElse 

if then else

NaN 

NaN.

UninterpretedFunction 

Uninterpreted function.

enum FormulaKind
strong

Kinds of symbolic formulas.

Enumerator
False 

True 

Var 

Boolean Variable.

Eq 

=

Neq 

!=

Gt 

>

Geq 

>=

Lt 

<

Leq 

<=

And 

Conjunction (∧)

Or 

Disjunction (∨)

Not 

Negation (¬)

Forall 

Universal quantification (∀)

Isnan 

NaN check predicate.

PositiveSemidefinite 

Positive semidefinite matrix.

Function Documentation

Expression abs ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression acos ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression asin ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression atan ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression atan2 ( const Expression e1,
const Expression e2 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression drake::symbolic::ceil ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

std::enable_if< std::is_base_of<Eigen::MatrixBase<DerivedA>, DerivedA>::value && std::is_base_of<Eigen::MatrixBase<DerivedB>, DerivedB>::value && std::is_same<typename DerivedA::Scalar, Variable>::value && std::is_same<typename DerivedB::Scalar, Variable>::value, bool>::type drake::symbolic::CheckStructuralEquality ( const DerivedA &  m1,
const DerivedB &  m2 
)

Checks if two Eigen::Matrix<Variable> m1 and m2 are structurally equal.

That is, it returns true if and only if m1(i, j) is structurally equal to m2(i, j) for all i, j.

std::enable_if< std::is_base_of<Eigen::MatrixBase<DerivedA>, DerivedA>::value && std::is_base_of<Eigen::MatrixBase<DerivedB>, DerivedB>::value && std::is_same<typename DerivedA::Scalar, Expression>::value && std::is_same<typename DerivedB::Scalar, Expression>::value, bool>::type drake::symbolic::CheckStructuralEquality ( const DerivedA &  m1,
const DerivedB &  m2 
)

Checks if two Eigen::Matrix<Expression> m1 and m2 are structurally equal.

That is, it returns true if and only if m1(i, j) is structurally equal to m2(i, j) for all i, j.

Here is the caller graph for this function:

Expression cos ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression cosh ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression drake::symbolic::DifferentiatePow ( const Expression f,
const Expression g,
const Variable x 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression exp ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression drake::symbolic::floor ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Formula forall ( const Variables vars,
const Formula f 
)

Returns a formula f, universally quantified by variables vars.

Here is the caller graph for this function:

const Expression & get_argument ( const Expression e)

Returns the argument in the unary expression e.

Precondition
{e is a unary expression.}
const std::map< Expression, Expression > & get_base_to_exponent_map_in_multiplication ( const Expression e)

Returns the map from a base expression to its exponent expression in the multiplication expression e.

For instance, given 7 * x^2 * y^3 * z^x, the return value maps 'x' to 2, 'y' to 3, and 'z' to 'x'.

Precondition
{e is a multiplication expression.}

Here is the caller graph for this function:

double get_constant_in_addition ( const Expression e)

Returns the constant part of the addition expression e.

For instance, given 7 + 2 * x + 3 * y, it returns 7.

Precondition
{e is an addition expression.}

Here is the caller graph for this function:

double get_constant_in_multiplication ( const Expression e)

Returns the constant part of the multiplication expression e.

For instance, given 7 * x^2 * y^3, it returns 7.

Precondition
{e is a multiplication expression.}

Here is the caller graph for this function:

double get_constant_value ( const Expression e)

Returns the constant value of the constant expression e.

Precondition
{e is a constant expression.}

Here is the caller graph for this function:

const std::map< Expression, double > & get_expr_to_coeff_map_in_addition ( const Expression e)

Returns the map from an expression to its coefficient in the addition expression e.

For instance, given 7 + 2 * x + 3 * y, the return value maps 'x' to 2 and 'y' to 3.

Precondition
{e is an addition expression.}

Here is the caller graph for this function:

const Expression & get_first_argument ( const Expression e)

Returns the first argument of the binary expression e.

Precondition
{e is a binary expression.}

Here is the caller graph for this function:

const Expression & get_lhs_expression ( const Formula f)

Returns the lhs-argument of a relational formula f.

Precondition
{f is a relational formula.}

Here is the caller graph for this function:

const MatrixX< Expression > & get_matrix_in_positive_semidefinite ( const Formula f)

Returns the matrix in a positive-semidefinite formula f.

Precondition
{f is a positive-semidefinite formula.}

Here is the caller graph for this function:

const Formula & get_operand ( const Formula f)

Returns the formula in a negation formula f.

Precondition
{f is a negation formula.}

Here is the caller graph for this function:

const std::set< Formula > & get_operands ( const Formula f)

Returns the set of formulas in a n-ary formula f.

Precondition
{f is a n-ary formula.}

Here is the caller graph for this function:

const Formula & get_quantified_formula ( const Formula f)

Returns the quantified formula in a forall formula f.

Precondition
{f is a forall formula.}

Here is the caller graph for this function:

const Variables & get_quantified_variables ( const Formula f)

Returns the quantified variables in a forall formula f.

Precondition
{f is a forall formula.}

Here is the caller graph for this function:

const Expression & get_rhs_expression ( const Formula f)

Returns the rhs-argument of a relational formula f.

Precondition
{f is a relational formula.}

Here is the caller graph for this function:

const Expression & get_second_argument ( const Expression e)

Returns the second argument of the binary expression e.

Precondition
{e is a binary expression.}

Here is the caller graph for this function:

const std::string & get_uninterpreted_function_name ( const Expression e)

Returns the name of an uninterpreted-function expression e.

Precondition
{e is an uninterpreted-function expression.}
const Variable & get_variable ( const Formula f)

Returns the embedded variable in the variable formula f.

Precondition
f is a variable formula.
const Variable & get_variable ( const Expression e)

Returns the embedded variable in the variable expression e.

Precondition
{e is a variable expression.}

Here is the caller graph for this function:

Expression if_then_else ( const Formula f_cond,
const Expression e_then,
const Expression e_else 
)
  if_then_else(cond, expr_then, expr_else)

The value returned by the above if-then-else expression is expr_then if cond is evaluated to true. Otherwise, it returns expr_else.

The semantics is similar to the C++'s conditional expression constructed by its ternary operator, ?:. However, there is a key difference between the C++'s conditional expression and our if_then_else expression in a way the arguments are evaluated during the construction.

  • In case of the C++'s conditional expression, cond ? expr_then : expr_else, the then expression expr_then (respectively, the else expression expr_else) is only evaluated when the conditional expression cond is evaluated to true (respectively, when cond is evaluated to false).
  • In case of the symbolic expression, if_then_else(cond, expr_then, expr_else), however, both arguments expr_then and expr_else are evaluated first and then passed to the if_then_else function.
Note
This function returns an expression and it is different from the C++'s if-then-else statement.
While it is still possible to define min, max, abs math functions using if_then_else expression, it is highly recommended to use the provided native definitions for them because it allows solvers to detect specific math functions and to have a room for special optimizations.
More information about the C++'s conditional expression and ternary operator is available at http://en.cppreference.com/w/cpp/language/operator_other#Conditional_operator.

Here is the call graph for this function:

Here is the caller graph for this function:

Variables intersect ( const Variables vars1,
const Variables vars2 
)

Returns the intersection of vars1 and vars2.

This function has a time complexity of O(N₁ + N₂) where N₁ and N₂ are the size of vars1 and vars2 respectively.

Here is the caller graph for this function:

bool is_abs ( const Expression e)

Checks if e is an abs expression.

Here is the caller graph for this function:

bool is_abs ( const ExpressionCell c)

Checks if c is an absolute-value-function expression.

Here is the call graph for this function:

bool is_acos ( const Expression e)

Checks if e is an arccosine expression.

Here is the caller graph for this function:

bool is_acos ( const ExpressionCell c)

Checks if c is an arccosine expression.

Here is the call graph for this function:

bool is_addition ( const Expression e)

Checks if e is an addition expression.

Here is the caller graph for this function:

bool is_addition ( const ExpressionCell c)

Checks if c is an addition expression.

Here is the call graph for this function:

bool is_asin ( const Expression e)

Checks if e is an arcsine expression.

Here is the caller graph for this function:

bool is_asin ( const ExpressionCell c)

Checks if c is an arcsine expression.

Here is the call graph for this function:

bool is_atan ( const Expression e)

Checks if e is an arctangent expression.

Here is the caller graph for this function:

bool is_atan ( const ExpressionCell c)

Checks if c is an arctangent expression.

Here is the call graph for this function:

bool is_atan2 ( const Expression e)

Checks if e is an arctangent2 expression.

Here is the caller graph for this function:

bool is_atan2 ( const ExpressionCell c)

Checks if c is a arctangent2 expression.

Here is the call graph for this function:

bool drake::symbolic::is_ceil ( const Expression e)

Here is the caller graph for this function:

bool is_ceil ( const ExpressionCell c)

Checks if c is a ceil expression.

Here is the call graph for this function:

bool is_conjunction ( const Formula f)

Checks if f is a conjunction (∧).

Here is the caller graph for this function:

bool is_conjunction ( const FormulaCell f)

Checks if f is a conjunction (∧).

Here is the call graph for this function:

bool is_constant ( const Expression e)

Checks if e is a constant expression.

Here is the caller graph for this function:

bool is_constant ( const Expression e,
double  v 
)

Checks if e is a constant expression representing v.

bool is_constant ( const ExpressionCell c)

Checks if c is a constant expression.

Here is the call graph for this function:

bool is_cos ( const Expression e)

Checks if e is a cosine expression.

Here is the caller graph for this function:

bool is_cos ( const ExpressionCell c)

Checks if c is a cosine expression.

Here is the call graph for this function:

bool is_cosh ( const Expression e)

Checks if e is a hyperbolic-cosine expression.

Here is the caller graph for this function:

bool is_cosh ( const ExpressionCell c)

Checks if c is a hyperbolic-cosine expression.

Here is the call graph for this function:

bool is_disjunction ( const Formula f)

Checks if f is a disjunction (∨).

Here is the caller graph for this function:

bool is_disjunction ( const FormulaCell f)

Checks if f is a disjunction (∨).

Here is the call graph for this function:

bool is_division ( const Expression e)

Checks if e is a division expression.

Here is the caller graph for this function:

bool is_division ( const ExpressionCell c)

Checks if c is a division expression.

Here is the call graph for this function:

bool is_equal_to ( const Formula f)

Checks if f is a formula representing equality (==).

Here is the caller graph for this function:

bool is_equal_to ( const FormulaCell f)

Checks if f is a formula representing equality (==).

Here is the call graph for this function:

bool is_exp ( const Expression e)

Checks if e is an exp expression.

Here is the caller graph for this function:

bool is_exp ( const ExpressionCell c)

Checks if c is an exp expression.

Here is the call graph for this function:

bool is_false ( const Formula f)

Checks if f is structurally equal to False formula.

Here is the caller graph for this function:

bool is_false ( const FormulaCell f)

Checks if f is structurally equal to False formula.

Here is the call graph for this function:

bool drake::symbolic::is_floor ( const Expression e)

Here is the caller graph for this function:

bool is_floor ( const ExpressionCell c)

Checks if c is a floor expression.

Here is the call graph for this function:

bool is_forall ( const Formula f)

Checks if f is a Forall formula (∀).

Here is the caller graph for this function:

bool is_forall ( const FormulaCell f)

Checks if f is a Forall formula (∀).

Here is the call graph for this function:

bool is_greater_than ( const Formula f)

Checks if f is a formula representing greater-than (>).

Here is the caller graph for this function:

bool is_greater_than ( const FormulaCell f)

Checks if f is a formula representing greater-than (>).

Here is the call graph for this function:

bool is_greater_than_or_equal_to ( const Formula f)

Checks if f is a formula representing greater-than-or-equal-to (>=).

Here is the caller graph for this function:

bool is_greater_than_or_equal_to ( const FormulaCell f)

Checks if f is a formula representing greater-than-or-equal-to (>=).

Here is the call graph for this function:

bool is_if_then_else ( const Expression e)

Checks if e is an if-then-else expression.

Here is the caller graph for this function:

bool is_if_then_else ( const ExpressionCell c)

Checks if c is an if-then-else expression.

Here is the call graph for this function:

bool is_isnan ( const Formula f)

Checks if f is an isnan formula.

Here is the caller graph for this function:

bool is_isnan ( const FormulaCell f)

Checks if f is an isnan formula.

Here is the call graph for this function:

bool is_less_than ( const Formula f)

Checks if f is a formula representing less-than (<).

Here is the caller graph for this function:

bool is_less_than ( const FormulaCell f)

Checks if f is a formula representing less-than (<).

Here is the call graph for this function:

bool is_less_than_or_equal_to ( const Formula f)

Checks if f is a formula representing less-than-or-equal-to (<=).

Here is the caller graph for this function:

bool is_less_than_or_equal_to ( const FormulaCell f)

Checks if f is a formula representing less-than-or-equal-to (<=).

Here is the call graph for this function:

bool is_log ( const Expression e)

Checks if e is a log expression.

Here is the caller graph for this function:

bool is_log ( const ExpressionCell c)

Checks if c is a log expression.

Here is the call graph for this function:

bool is_max ( const Expression e)

Checks if e is a max expression.

Here is the caller graph for this function:

bool is_max ( const ExpressionCell c)

Checks if c is a max expression.

Here is the call graph for this function:

bool is_min ( const Expression e)

Checks if e is a min expression.

Here is the caller graph for this function:

bool is_min ( const ExpressionCell c)

Checks if c is a min expression.

Here is the call graph for this function:

bool is_multiplication ( const Expression e)

Checks if e is a multiplication expression.

Here is the caller graph for this function:

bool is_multiplication ( const ExpressionCell c)

Checks if c is an multiplication expression.

Here is the call graph for this function:

bool is_nan ( const Expression e)

Checks if e is NaN.

Here is the call graph for this function:

bool is_nary ( const Formula f)

Checks if f is a n-ary formula ({∧, ∨}).

Here is the caller graph for this function:

bool drake::symbolic::is_nary ( const FormulaCell f)

Here is the call graph for this function:

bool is_neg_one ( const Expression e)

Checks if e is -1.0.

Here is the caller graph for this function:

bool is_negation ( const Formula f)

Checks if f is a negation (¬).

Here is the caller graph for this function:

bool is_negation ( const FormulaCell f)

Checks if f is a negation (¬).

Here is the call graph for this function:

bool is_not_equal_to ( const Formula f)

Checks if f is a formula representing disequality (!=).

Here is the caller graph for this function:

bool is_not_equal_to ( const FormulaCell f)

Checks if f is a formula representing disequality (!=).

Here is the call graph for this function:

bool is_one ( const Expression e)

Checks if e is 1.0.

Here is the caller graph for this function:

bool is_positive_semidefinite ( const Formula f)

Checks if f is a positive-semidefinite formula.

Here is the caller graph for this function:

bool is_positive_semidefinite ( const FormulaCell f)

Checks if f is a positive semidefinite formula.

Here is the call graph for this function:

bool is_pow ( const Expression e)

Checks if e is a power-function expression.

Here is the caller graph for this function:

bool is_pow ( const ExpressionCell c)

Checks if c is a power-function expression.

Here is the call graph for this function:

bool is_relational ( const Formula f)

Checks if f is a relational formula ({==, !=, >, >=, <, <=}).

Here is the caller graph for this function:

bool is_relational ( const FormulaCell f)

Checks if f is a relational formula ({==, !=, >, >=, <, <=}).

Here is the call graph for this function:

bool is_sin ( const Expression e)

Checks if e is a sine expression.

Here is the caller graph for this function:

bool is_sin ( const ExpressionCell c)

Checks if c is a sine expression.

Here is the call graph for this function:

bool is_sinh ( const Expression e)

Checks if e is a hyperbolic-sine expression.

Here is the caller graph for this function:

bool is_sinh ( const ExpressionCell c)

Checks if c is a hyperbolic-sine expression.

Here is the call graph for this function:

bool is_sqrt ( const Expression e)

Checks if e is a square-root expression.

Here is the caller graph for this function:

bool is_sqrt ( const ExpressionCell c)

Checks if c is a square-root expression.

Here is the call graph for this function:

bool is_tan ( const Expression e)

Checks if e is a tangent expression.

Here is the caller graph for this function:

bool is_tan ( const ExpressionCell c)

Checks if c is a tangent expression.

Here is the call graph for this function:

bool is_tanh ( const Expression e)

Checks if e is a hyperbolic-tangent expression.

Here is the caller graph for this function:

bool is_tanh ( const ExpressionCell c)

Checks if c is a hyperbolic-tangent expression.

Here is the call graph for this function:

bool is_true ( const Formula f)

Checks if f is structurally equal to True formula.

Here is the caller graph for this function:

bool is_true ( const FormulaCell f)

Checks if f is structurally equal to True formula.

Here is the call graph for this function:

bool is_two ( const Expression e)

Checks if e is 2.0.

Here is the caller graph for this function:

bool is_uninterpreted_function ( const Expression e)

Checks if e is an uninterpreted-function expression.

Here is the caller graph for this function:

bool is_uninterpreted_function ( const ExpressionCell c)

Checks if c is an uninterpreted-function expression.

Here is the call graph for this function:

bool is_variable ( const Formula f)

Checks if f is a variable formula.

bool is_variable ( const FormulaCell f)

Checks if f is a variable formula.

Here is the call graph for this function:

bool is_variable ( const Expression e)

Checks if e is a variable expression.

Here is the caller graph for this function:

bool is_variable ( const ExpressionCell c)

Checks if c is a variable expression.

Here is the call graph for this function:

bool is_zero ( const Expression e)

Checks if e is 0.0.

Here is the caller graph for this function:

Formula isnan ( const Expression e)

Returns a Formula for the predicate isnan(e) to the given expression.

This serves as the argument-dependent lookup related to std::isnan(double). When evaluated, this Formula will return false when the e.Evaluate() is not NaN.

Exceptions
std::runtime_errorif NaN is detected during evaluation.

Here is the caller graph for this function:

MatrixX< Expression > Jacobian ( const Eigen::Ref< const VectorX< Expression >> &  f,
const std::vector< Variable > &  vars 
)

Computes the Jacobian matrix J of the vector function f with respect to vars.

J(i,j) contains ∂f(i)/∂vars(j).

For example, Jacobian([x * cos(y), x * sin(y), x^2], {x, y}) returns the following 3x2 matrix:

 = |cos(y)   -x * sin(y)|
   |sin(y)    x * cos(y)|
   | 2 * x             0|
 
Precondition
{vars is non-empty}.

Here is the caller graph for this function:

MatrixX< Expression > Jacobian ( const Eigen::Ref< const VectorX< Expression >> &  f,
const Eigen::Ref< const VectorX< Variable >> &  vars 
)

Computes the Jacobian matrix J of the vector function f with respect to vars.

J(i,j) contains ∂f(i)/∂vars(j).

Precondition
{vars is non-empty}.

Here is the call graph for this function:

Expression log ( const Expression e)

Here is the call graph for this function:

Here is the caller graph for this function:

Formula make_conjunction ( const std::set< Formula > &  formulas)

Returns a conjunction of formulas.

It performs the following simplification:

  • make_conjunction({}) returns True.
  • make_conjunction({f₁}) returns f₁.
  • If False ∈ formulas, it returns False.
  • If True ∈ formulas, it will not appear in the return value.
  • Nested conjunctions will be flattened. For example, make_conjunction({f₁, f₂ ∧ f₃}) returns f₁ ∧ f₂ ∧ f₃.

Here is the call graph for this function:

Here is the caller graph for this function:

Formula make_disjunction ( const std::set< Formula > &  formulas)

Returns a disjunction of formulas.

It performs the following simplification:

  • make_disjunction({}) returns False.
  • make_disjunction({f₁}) returns f₁.
  • If True ∈ formulas, it returns True.
  • If False ∈ formulas, it will not appear in the return value.
  • Nested disjunctions will be flattened. For example, make_disjunction({f₁, f₂ ∨ f₃}) returns f₁ ∨ f₂ ∨ f₃.

Here is the call graph for this function:

Here is the caller graph for this function:

Expression max ( const Expression e1,
const Expression e2 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression min ( const Expression e1,
const Expression e2 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Eigen::Matrix< Monomial, Eigen::Dynamic, 1 > MonomialBasis ( const Variables vars,
int  degree 
)

Returns all monomials up to a given degree under the graded reverse lexicographic order.

Note that graded reverse lexicographic order uses the total order among Variable which is based on a variable's unique ID. For example, for a given variable ordering x > y > z, MonomialBasis({x, y, z}, 2) returns a column vector [x^2, xy, y^2, xz, yz, z^2, x, y, z, 1].

Precondition
vars is a non-empty set.
degree is a non-negative integer.

Here is the caller graph for this function:

Eigen::Matrix<Monomial, NChooseK(n + degree, degree), 1> drake::symbolic::MonomialBasis ( const Variables vars)

Returns all monomials up to a given degree under the graded reverse lexicographic order.

Template Parameters
nnumber of variables.
degreemaximum total degree of monomials to compute.
Precondition
vars is a non-empty set.
vars.size() == n.

Here is the call graph for this function:

constexpr int drake::symbolic::NChooseK ( int  n,
int  k 
)
Formula operator! ( const Formula f)

Here is the call graph for this function:

Formula operator! ( const Variable v)

Here is the call graph for this function:

Formula operator!= ( const Expression e1,
const Expression e2 
)

Here is the call graph for this function:

std::enable_if< std::is_same<typename Eigen::internal::traits<DerivedA>::XprKind, Eigen::ArrayXpr>::value && std::is_same<typename Eigen::internal::traits<DerivedB>::XprKind, Eigen::ArrayXpr>::value && std::is_same<decltype(typename DerivedA::Scalar() != typename DerivedB::Scalar()), Formula>::value, typename detail::RelationalOpTraits<DerivedA, DerivedB>::ReturnType>::type drake::symbolic::operator!= ( const DerivedA &  a1,
const DerivedB &  a2 
)

Returns an Eigen array of symbolic formulas where each element includes element-wise comparison of two arrays a1 and a2 using not-equal operator (!=).

std::enable_if< std::is_same<typename Eigen::internal::traits<Derived>::XprKind, Eigen::ArrayXpr>::value && std::is_same<decltype(typename Derived::Scalar() != ScalarType()), Formula>::value, Eigen::Array<Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime> >::type drake::symbolic::operator!= ( const Derived &  a,
const ScalarType &  v 
)

Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between an array a and a scalar v using not-equal operator (!=).

That is, for all i and j, the (i, j)-th entry of (a != v) has a symbolic formula a(i, j) != v.

std::enable_if< std::is_same<typename Eigen::internal::traits<Derived>::XprKind, Eigen::ArrayXpr>::value && std::is_same<decltype(ScalarType() != typename Derived::Scalar()), Formula>::value, Eigen::Array<Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime> >::type drake::symbolic::operator!= ( const ScalarType &  v,
const Derived &  a 
)

Returns an Eigen array of symbolic formulas where each element includes element-wise comparison between a scalar v and an array using not-equal operator (!=).

That is, for all i and j, the (i, j)-th entry of (v != a) has a symbolic formula v != a(i, j).

std::enable_if< std::is_same<typename Eigen::internal::traits<DerivedA>::XprKind, Eigen::MatrixXpr>::value && std::is_same<typename Eigen::internal::traits<DerivedB>::XprKind, Eigen::MatrixXpr>::value && std::is_same<decltype(typename DerivedA::Scalar() != typename DerivedB::Scalar()), Formula>::value, Formula>::type drake::symbolic::operator!= ( const DerivedA &  m1,
const DerivedB &  m2 
)

Returns a symbolic formula representing element-wise comparison between two matrices m1 and m2 using not-equal (!=) operator.

The following table describes the return type of m1 != m2.

LHS \ RHS EM<Expression> EM<Variable> EM<double>
EM<Expression> Formula Formula Formula
EM<Variable> Formula Formula Formula
EM<double> Formula Formula bool

In the table, EM is a short-hand of Eigen::Matrix.

Note that this function does not provide operator overloading for the following case. It returns bool and is provided by Eigen.

  • Eigen::Matrix<double> != Eigen::Matrix<double>

Here is the call graph for this function:

Formula operator&& ( const Formula f1,
const Formula f2 
)

Here is the call graph for this function:

Formula operator&& ( const Variable v,
const Formula f 
)

Here is the call graph for this function:

Formula operator&& ( const Formula f,
const Variable v 
)

Here is the call graph for this function:

Formula operator&& ( const Variable v1,
const Variable v2 
)

Here is the call graph for this function:

Eigen::Matrix<Polynomial, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime> drake::symbolic::operator* ( const MatrixL &  lhs,
const MatrixR &  rhs 
)

Provides the following seven operations:

  • Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Monomial> => Matrix<Polynomial>
Note
that these operator overloadings are necessary even after providing Eigen::ScalarBinaryOpTraits. See https://stackoverflow.com/questions/41494288/mixing-scalar-types-in-eigen for more information.

Here is the call graph for this function:

Monomial operator* ( Monomial  m1,
const Monomial m2 
)

Returns a multiplication of two monomials, m1 and m2.

Expression operator* ( Expression  lhs,
const Expression rhs 
)

Here is the caller graph for this function:

Polynomial operator* ( Polynomial  p1,
const Polynomial p2 
)
Polynomial operator* ( Polynomial  p,
const Monomial m 
)
Polynomial operator* ( const Monomial m,
Polynomial  p 
)
Polynomial operator* ( const double  c,
Polynomial  p 
)
Polynomial operator* ( Polynomial  p,
const double  c 
)
Polynomial operator* ( const Monomial m,
double  c 
)

Here is the call graph for this function:

Polynomial operator* ( double  c,
const Monomial m 
)

Here is the call graph for this function:

std::enable_if< std::is_base_of<Eigen::MatrixBase<MatrixL>, MatrixL>::value && std::is_base_of<Eigen::MatrixBase<MatrixR>, MatrixR>::value && std::is_same<typename MatrixL::Scalar, Expression>::value && std::is_same<typename MatrixR::Scalar, double>::value, Eigen::Matrix<Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime> >::type drake::symbolic::operator* ( const MatrixL &  lhs,
const MatrixR &  rhs 
)

Provides the following seven operations:

  • Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Monomial> => Matrix<Polynomial>
Note
that these operator overloadings are necessary even after providing Eigen::ScalarBinaryOpTraits. See https://stackoverflow.com/questions/41494288/mixing-scalar-types-in-eigen for more information.
std::enable_if< std::is_base_of<Eigen::MatrixBase<MatrixL>, MatrixL>::value && std::is_base_of<Eigen::MatrixBase<MatrixR>, MatrixR>::value && std::is_same<typename MatrixL::Scalar, double>::value && std::is_same<typename MatrixR::Scalar, Expression>::value, Eigen::Matrix<Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime> >::type drake::symbolic::operator* ( const MatrixL &  lhs,
const MatrixR &  rhs 
)

Provides the following seven operations:

  • Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Monomial> => Matrix<Polynomial>
Note
that these operator overloadings are necessary even after providing Eigen::ScalarBinaryOpTraits. See https://stackoverflow.com/questions/41494288/mixing-scalar-types-in-eigen for more information.

Here is the call graph for this function:

std::enable_if< std::is_base_of<Eigen::MatrixBase<MatrixL>, MatrixL>::value && std::is_base_of<Eigen::MatrixBase<MatrixR>, MatrixR>::value && std::is_same<typename MatrixL::Scalar, Expression>::value && std::is_same<typename MatrixR::Scalar, Variable>::value, Eigen::Matrix<Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime> >::type drake::symbolic::operator* ( const MatrixL &  lhs,
const MatrixR &  rhs 
)

Provides the following seven operations:

  • Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Monomial> => Matrix<Polynomial>
Note
that these operator overloadings are necessary even after providing Eigen::ScalarBinaryOpTraits. See https://stackoverflow.com/questions/41494288/mixing-scalar-types-in-eigen for more information.
std::enable_if< std::is_base_of<Eigen::MatrixBase<MatrixL>, MatrixL>::value && std::is_base_of<Eigen::MatrixBase<MatrixR>, MatrixR>::value && std::is_same<typename MatrixL::Scalar, Variable>::value && std::is_same<typename MatrixR::Scalar, Expression>::value, Eigen::Matrix<Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime> >::type drake::symbolic::operator* ( const MatrixL &  lhs,
const MatrixR &  rhs 
)

Provides the following seven operations:

  • Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Monomial> => Matrix<Polynomial>
Note
that these operator overloadings are necessary even after providing Eigen::ScalarBinaryOpTraits. See https://stackoverflow.com/questions/41494288/mixing-scalar-types-in-eigen for more information.
std::enable_if< std::is_base_of<Eigen::MatrixBase<MatrixL>, MatrixL>::value && std::is_base_of<Eigen::MatrixBase<MatrixR>, MatrixR>::value && std::is_same<typename MatrixL::Scalar, Variable>::value && std::is_same<typename MatrixR::Scalar, double>::value, Eigen::Matrix<Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime> >::type drake::symbolic::operator* ( const MatrixL &  lhs,
const MatrixR &  rhs 
)

Provides the following seven operations:

  • Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Monomial> => Matrix<Polynomial>
Note
that these operator overloadings are necessary even after providing Eigen::ScalarBinaryOpTraits. See https://stackoverflow.com/questions/41494288/mixing-scalar-types-in-eigen for more information.
std::enable_if< std::is_base_of<Eigen::MatrixBase<MatrixL>, MatrixL>::value && std::is_base_of<Eigen::MatrixBase<MatrixR>, MatrixR>::value && std::is_same<typename MatrixL::Scalar, double>::value && std::is_same<typename MatrixR::Scalar, Variable>::value, Eigen::Matrix<Expression, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime> >::type drake::symbolic::operator* ( const MatrixL &  lhs,
const MatrixR &  rhs 
)

Provides the following seven operations:

  • Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
  • Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Polynomial> => Matrix<Polynomial>
  • Matrix<double> * Matrix<Monomial> => Matrix<Polynomial>
Note
that these operator overloadings are necessary even after providing Eigen::ScalarBinaryOpTraits. See https://stackoverflow.com/questions/41494288/mixing-scalar-types-in-eigen for more information.
auto drake::symbolic::operator* ( const Eigen::Transform< Expression, Dim, LhsMode, LhsOptions > &  t1,
const Eigen::Transform< double, Dim, RhsMode, RhsOptions > &  t2 
)

Transform<double> * Transform<Expression> => Transform<Expression>

auto drake::symbolic::operator* ( const Eigen::Transform< double, Dim, LhsMode, LhsOptions > &  t1,
const Eigen::Transform< Expression, Dim, RhsMode, RhsOptions > &  t2 
)

Transform<Expression> * Transform<double> => Transform<Expression>

Expression operator* ( const Variable lhs,
const Variable rhs 
)
Expression operator* ( Expression  lhs,
const Variable rhs 
)
Expression operator* ( const Variable lhs,
Expression  rhs 
)
Expression & operator*= ( Expression lhs,
const Expression rhs 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression & operator*= ( Expression lhs,
const Variable rhs 
)
Variables operator+ ( Variables  vars1,
const Variables vars2 
)

Returns set-union of var1 and var2.

Variables operator+ ( Variables  vars,
const Variable var 
)

Returns set-union of vars and {var}.

Variables operator+ ( const Variable var,
Variables  vars 
)

Returns set-union of {var} and vars.

Expression operator+ ( Expression  lhs,
const Expression rhs 
)

Here is the caller graph for this function:

Polynomial operator+ ( Polynomial  p1,
const Polynomial p2 
)
Polynomial operator+ ( Polynomial  p,
const Monomial m 
)
Polynomial operator+ ( const Monomial m,
Polynomial  p 
)
Polynomial operator+ ( const Monomial m1,
const Monomial m2 
)

Here is the call graph for this function:

Polynomial operator+ ( Polynomial  p,
const double  c 
)
Polynomial operator+ ( const double  c,
Polynomial  p 
)
Polynomial operator+ ( const Monomial m,
const double  c 
)

Here is the call graph for this function:

Polynomial operator+ ( const double  c,
const Monomial m 
)

Here is the call graph for this function:

Expression operator+ ( const Variable lhs,
const Variable rhs 
)
Expression operator+ ( Expression  lhs,
const Variable rhs 
)
Expression operator+ ( const Variable lhs,
Expression  rhs 
)
Expression operator+ ( const Variable var)
Variables operator+= ( Variables vars1,
const Variables vars2 
)

Updates var1 with the result of set-union(var1, var2).

Here is the call graph for this function:

Variables operator+= ( Variables vars,
const Variable var 
)

Updates vars with the result of set-union(vars, { var }).

Here is the call graph for this function:

Expression & operator+= ( Expression lhs,
const Expression rhs 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression & operator+= ( Expression lhs,
const Variable rhs 
)
Variables operator- ( Variables  vars1,
const Variables vars2 
)

Returns set-minus(var1, vars2).

Variables operator- ( Variables  vars,
const Variable var 
)

Returns set-minus(vars, { var }).

Here is the call graph for this function:

Expression operator- ( Expression  lhs,
const Expression rhs 
)

Here is the caller graph for this function:

Expression operator- ( const Expression e)

Here is the call graph for this function:

Polynomial operator- ( Polynomial  p)

Unary minus operation for polynomial.

Polynomial operator- ( Polynomial  p1,
const Polynomial p2 
)
Polynomial operator- ( Polynomial  p,
const Monomial m 
)
Polynomial operator- ( const Monomial m,
Polynomial  p 
)
Polynomial operator- ( const Monomial m1,
const Monomial m2 
)

Here is the call graph for this function:

Polynomial operator- ( Polynomial  p,
const double  c 
)
Polynomial operator- ( const double  c,
Polynomial  p 
)
Polynomial operator- ( const Monomial m,
const double  c 
)

Here is the call graph for this function:

Polynomial operator- ( const double  c,
const Monomial m 
)

Here is the call graph for this function:

Expression operator- ( const Variable lhs,
const Variable rhs 
)
Expression operator- ( Expression  lhs,
const Variable rhs 
)
Expression operator- ( const Variable lhs,
const Expression rhs 
)

Here is the call graph for this function:

Expression operator- ( const Variable var)
Variables operator-= ( Variables vars1,
const Variables vars2 
)

Updates var1 with the result of set-minus(var1, var2).

Here is the call graph for this function:

Variables operator-= ( Variables vars,
const Variable var 
)

Updates vars with the result of set-minus(vars, {var}).

Here is the call graph for this function:

Expression & operator-= ( Expression lhs,
const Expression rhs 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression & operator-= ( Expression lhs,
const Variable rhs 
)
Expression operator/ ( Expression  lhs,
const Expression rhs 
)

Here is the caller graph for this function:

Expression operator/ ( const Variable lhs,
const Variable rhs 
)
Expression operator/ ( Expression  lhs,
const Variable rhs 
)
Expression operator/ ( const Variable lhs,
const Expression rhs 
)

Here is the call graph for this function:

Expression & operator/= ( Expression lhs,
const Expression rhs 
)

Here is the call graph for this function:

Here is the caller graph for this function:

Expression & operator/= ( Expression lhs,
const Variable rhs 
)
bool operator< ( FormulaKind  k1,
FormulaKind  k2 
)

Here is the call graph for this function:

bool operator< ( ExpressionKind  k1,
ExpressionKind  k2 
)

Total ordering between ExpressionKinds.

Here is the call graph for this function:

bool drake::symbolic::operator< ( const Variables vars1,
const Variables vars2 
)
Formula operator< ( const Expression e1,
const Expression e2 
)

Here is the call graph for this function:

std::enable_if< std::is_same<typename Eigen::internal::traits<DerivedA>::XprKind, Eigen::ArrayXpr>::value && std::is_same<typename Eigen::internal::traits<DerivedB>::XprKind, Eigen::ArrayXpr>::value && std