drake::symbolic Namespace Reference

Classes
struct	BasisElementGradedReverseLexOrder
	Implements Graded reverse lexicographic order. More...
class	BinaryExpressionCell
	Represents the base class for binary expressions. More...
class	ChebyshevBasisElement
	ChebyshevBasisElement represents an element of Chebyshev polynomial basis, written as the product of Chebyshev polynomials, in the form Tₚ₀(x₀)Tₚ₁(x₁)...Tₚₙ(xₙ), where each Tₚᵢ(xᵢ) is a (univariate) Chebyshev polynomial of degree pᵢ. More...
class	ChebyshevPolynomial
	Represents the Chebyshev polynomial of the first kind Tₙ(x). More...
class	CodeGenVisitor
	Visitor class for code generation. 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	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 ∧ ... ∧ fn). 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 ∨ ... ∨ fn). 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...
class	GenericPolynomial
	Represents symbolic generic polynomials using a given basis (for example, monomial basis, Chebyshev basis, etc). 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	MonomialBasisElement
	MonomialBasisElement 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	PolynomialBasisElement
	Each polynomial p(x) can be written as a linear combination of its basis elements p(x) = ∑ᵢ cᵢ * ϕᵢ(x), where ϕᵢ(x) is the i'th element in the basis, cᵢ is the coefficient of that element. More...
class	RationalFunction
	Represents symbolic rational function. More...
class	RelationalFormulaCell
	Represents the base class for relational operators (==, !=, <, <=, >, >=). More...
class	RewritingRule
	A RewritingRule, lhs => rhs, consists of two Patterns lhs and rhs. More...
struct	SinCos
	Represents a pair of Variables corresponding to sin(q) and cos(q). 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>
template<typename BasisElement>
using	GenericPolynomialEnable
	Defines an explicit SFINAE alias for use with return types to dissuade CTAD from trying to instantiate an invalid GenericElement<> for operator overloads, (if that's actually the case).
using	Pattern = Expression
	A pattern is an expression which possibly includes variables which represent placeholders.
using	Rewriter = std::function<Expression(const Expression&)>
	A Rewriter is a function from an Expression to an Expression.
using	SinCosSubstitution = std::unordered_map<Variable, SinCos>

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

Functions
std::map< ChebyshevBasisElement, double >	operator* (const ChebyshevBasisElement &a, const ChebyshevBasisElement &b)
	Returns the product of two Chebyshev basis elements.
std::ostream &	operator<< (std::ostream &out, const ChebyshevBasisElement &m)
std::ostream &	operator<< (std::ostream &out, const ChebyshevPolynomial &p)
double	EvaluateChebyshevPolynomial (double var_val, int degree)
	Evaluates a Chebyshev polynomial at a given value.
std::string	CodeGen (const std::string &function_name, const std::vector< Variable > &parameters, const Expression &e)
	For a given symbolic expression e, generates two C functions, <function_name> and <function_name>_meta.
template<typename Derived>
std::string	CodeGen (const std::string &function_name, const std::vector< Variable > &parameters, const Eigen::PlainObjectBase< Derived > &M)
	For a given symbolic dense matrix M, generates two C functions, <function_name> and <function_name>_meta.
std::string	CodeGen (const std::string &function_name, const std::vector< Variable > &parameters, const Eigen::Ref< const Eigen::SparseMatrix< Expression, Eigen::ColMajor > > &M)
	For a given symbolic column-major sparse matrix M, generates two C functions, <function_name> and <function_name>_meta.
bool	IsAffine (const Eigen::Ref< const MatrixX< Expression > > &m, const Variables &vars)
	Checks if every element in m is affine in vars.
bool	IsAffine (const Eigen::Ref< const MatrixX< Expression > > &m)
	Checks if every element in m is affine.
void	DecomposeLinearExpressions (const Eigen::Ref< const VectorX< Expression > > &expressions, const Eigen::Ref< const VectorX< Variable > > &vars, EigenPtr< Eigen::MatrixXd > M)
	Decomposes expressions into M * vars.
void	DecomposeAffineExpressions (const Eigen::Ref< const VectorX< Expression > > &expressions, const Eigen::Ref< const VectorX< Variable > > &vars, EigenPtr< Eigen::MatrixXd > M, EigenPtr< Eigen::VectorXd > v)
	Decomposes expressions into M * vars + v.
void	ExtractAndAppendVariablesFromExpression (const symbolic::Expression &e, std::vector< Variable > *vars, std::unordered_map< symbolic::Variable::Id, int > *map_var_to_index)
	Given an expression e, extracts all variables inside e, appends these variables to vars if they are not included in vars yet.
std::pair< VectorX< Variable >, std::unordered_map< symbolic::Variable::Id, int > >	ExtractVariablesFromExpression (const symbolic::Expression &e)
	Given an expression e, extracts all variables inside e.
std::pair< VectorX< Variable >, std::unordered_map< Variable::Id, int > >	ExtractVariablesFromExpression (const Eigen::Ref< const VectorX< Expression > > &expressions)
	Overloads ExtractVariablesFromExpression but with a vector of expressions.
void	DecomposeQuadraticPolynomial (const symbolic::Polynomial &poly, const std::unordered_map< symbolic::Variable::Id, int > &map_var_to_index, Eigen::MatrixXd *Q, Eigen::VectorXd *b, double *c)
	Given a quadratic polynomial poly, decomposes it into the form 0.5 * x' Q * x + b' * x + c.
void	DecomposeAffineExpressions (const Eigen::Ref< const VectorX< symbolic::Expression > > &v, Eigen::MatrixXd *A, Eigen::VectorXd *b, VectorX< Variable > *vars)
	Given a vector of affine expressions v, decompose it to \( v = A vars + b \).
int	DecomposeAffineExpression (const symbolic::Expression &e, const std::unordered_map< symbolic::Variable::Id, int > &map_var_to_index, EigenPtr< Eigen::RowVectorXd > coeffs, double *constant_term)
	Decomposes an affine combination e = c0 + c1 * v1 + ... cn * vn into the following:
std::tuple< MatrixX< Expression >, VectorX< Expression >, VectorX< Expression > >	DecomposeLumpedParameters (const Eigen::Ref< const VectorX< Expression > > &f, const Eigen::Ref< const VectorX< Variable > > &parameters)
	Given a vector of Expressions f and a list of parameters we define all additional variables in f to be a vector of "non-parameter variables", n.
std::tuple< bool, Eigen::MatrixXd, Eigen::VectorXd, VectorX< Variable > >	DecomposeL2NormExpression (const symbolic::Expression &e, double psd_tol=1e-8, double coefficient_tol=1e-8)
	Decomposes an L2 norm e = |Ax+b|₂ into A, b, and the variable vector x (or returns false if the decomposition is not possible).
Environment	PopulateRandomVariables (Environment env, const Variables &variables, RandomGenerator *random_generator)
	Populates the environment env by sampling values for the unassigned random variables in variables using random_generator.
Expression	operator+ (Expression lhs, const Expression &rhs)
Expression &	operator+= (Expression &lhs, const Expression &rhs)
Expression	operator+ (const Expression &e)
Expression	operator- (Expression lhs, const Expression &rhs)
Expression &	operator-= (Expression &lhs, const Expression &rhs)
Expression	operator- (const Expression &e)
Expression	operator* (Expression lhs, const Expression &rhs)
Expression &	operator*= (Expression &lhs, const Expression &rhs)
Expression	operator/ (Expression lhs, const Expression &rhs)
Expression &	operator/= (Expression &lhs, const Expression &rhs)
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	clamp (const Expression &v, const Expression &lo, const Expression &hi)
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 (std::string name, std::vector< Expression > arguments)
	Constructs an uninterpreted-function expression with name and arguments.
void	swap (Expression &a, Expression &b)
std::ostream &	operator<< (std::ostream &os, const Expression &e)
bool	is_constant (const Expression &e)
	Checks if e is a constant expression.
bool	is_constant (const Expression &e, double v)
	Checks if e is a constant expression representing v.
bool	is_zero (const Expression &e)
	Checks if e is 0.0.
bool	is_one (const Expression &e)
	Checks if e is 1.0.
bool	is_neg_one (const Expression &e)
	Checks if e is -1.0.
bool	is_two (const Expression &e)
	Checks if e is 2.0.
bool	is_nan (const Expression &e)
	Checks if e is NaN.
bool	is_variable (const Expression &e)
	Checks if e is a variable expression.
bool	is_addition (const Expression &e)
	Checks if e is an addition expression.
bool	is_multiplication (const Expression &e)
	Checks if e is a multiplication expression.
bool	is_division (const Expression &e)
	Checks if e is a division expression.
bool	is_log (const Expression &e)
	Checks if e is a log expression.
bool	is_abs (const Expression &e)
	Checks if e is an abs expression.
bool	is_exp (const Expression &e)
	Checks if e is an exp expression.
bool	is_sqrt (const Expression &e)
	Checks if e is a square-root expression.
bool	is_pow (const Expression &e)
	Checks if e is a power-function expression.
bool	is_sin (const Expression &e)
	Checks if e is a sine expression.
bool	is_cos (const Expression &e)
	Checks if e is a cosine expression.
bool	is_tan (const Expression &e)
	Checks if e is a tangent expression.
bool	is_asin (const Expression &e)
	Checks if e is an arcsine expression.
bool	is_acos (const Expression &e)
	Checks if e is an arccosine expression.
bool	is_atan (const Expression &e)
	Checks if e is an arctangent expression.
bool	is_atan2 (const Expression &e)
	Checks if e is an arctangent2 expression.
bool	is_sinh (const Expression &e)
	Checks if e is a hyperbolic-sine expression.
bool	is_cosh (const Expression &e)
	Checks if e is a hyperbolic-cosine expression.
bool	is_tanh (const Expression &e)
	Checks if e is a hyperbolic-tangent expression.
bool	is_min (const Expression &e)
	Checks if e is a min expression.
bool	is_max (const Expression &e)
	Checks if e is a max expression.
bool	is_ceil (const Expression &e)
	Checks if e is a ceil expression.
bool	is_floor (const Expression &e)
	Checks if e is a floor expression.
bool	is_if_then_else (const Expression &e)
	Checks if e is an if-then-else expression.
bool	is_uninterpreted_function (const Expression &e)
	Checks if e is an uninterpreted-function expression.
double	get_constant_value (const Expression &e)
	Returns the constant value of the constant expression e.
const Variable &	get_variable (const Expression &e)
	Returns the embedded variable in the variable expression e.
const Expression &	get_argument (const Expression &e)
	Returns the argument in the unary expression e.
const Expression &	get_first_argument (const Expression &e)
	Returns the first argument of the binary expression e.
const Expression &	get_second_argument (const Expression &e)
	Returns the second argument of the binary expression e.
double	get_constant_in_addition (const Expression &e)
	Returns the constant part of the addition expression e.
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.
double	get_constant_in_multiplication (const Expression &e)
	Returns the constant part of the multiplication expression e.
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.
const std::string &	get_uninterpreted_function_name (const Expression &e)
	Returns the name of an uninterpreted-function expression e.
const std::vector< Expression > &	get_uninterpreted_function_arguments (const Expression &e)
	Returns the arguments of an uninterpreted-function expression e.
const Formula &	get_conditional_formula (const Expression &e)
	Returns the conditional formula in the if-then-else expression e.
const Expression &	get_then_expression (const Expression &e)
	Returns the 'then' expression in the if-then-else expression e.
const Expression &	get_else_expression (const Expression &e)
	Returns the 'else' expression in the if-then-else expression e.
Expression	operator+ (const Variable &var)
Expression	operator- (const Variable &var)
Expression	TaylorExpand (const Expression &f, const Environment &a, int order)
	Returns the Taylor series expansion of f around a of order order.
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Expression > &&std::is_same_v< typename MatrixR::Scalar, double >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, double > &&std::is_same_v< typename MatrixR::Scalar, Expression >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Expression > &&std::is_same_v< typename MatrixR::Scalar, Variable >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Variable > &&std::is_same_v< typename MatrixR::Scalar, Expression >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Variable > &&std::is_same_v< typename MatrixR::Scalar, double >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, double > &&std::is_same_v< typename MatrixR::Scalar, Variable >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Variable > &&std::is_same_v< typename MatrixR::Scalar, Variable >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
template<typename MatrixL, typename MatrixR>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Expression > &&std::is_same_v< typename MatrixR::Scalar, Expression >, internal::ExpressionMatMulResult< MatrixL, MatrixR > >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following matrix operations:
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>
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>
template<typename Derived>
std::enable_if_t< std::is_same_v< typename Derived::Scalar, Expression >, MatrixLikewise< double, Derived > >	Evaluate (const Eigen::MatrixBase< Derived > &m, const Environment &env=Environment{}, RandomGenerator *random_generator=nullptr)
	Evaluates a symbolic matrix m using env and random_generator.
Eigen::SparseMatrix< double >	Evaluate (const Eigen::Ref< const Eigen::SparseMatrix< Expression > > &m, const Environment &env=Environment{})
	Evaluates m using a given environment (by default, an empty environment).
template<typename Derived>
MatrixLikewise< Expression, Derived >	Substitute (const Eigen::MatrixBase< Derived > &m, const Substitution &subst)
	Substitutes a symbolic matrix m using a given substitution subst.
template<typename Derived>
MatrixLikewise< Expression, Derived >	Substitute (const Eigen::MatrixBase< Derived > &m, const Variable &var, const Expression &e)
	Substitutes var with e in a symbolic matrix m.
VectorX< Variable >	GetVariableVector (const Eigen::Ref< const VectorX< Expression > > &expressions)
	Constructs a vector of variables from the vector of variable expressions.
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.
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.
Variables	GetDistinctVariables (const Eigen::Ref< const MatrixX< Expression > > &v)
	Returns the distinct variables in the matrix of expressions.
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< DerivedA >, DerivedA > &&std::is_base_of_v< Eigen::MatrixBase< DerivedB >, DerivedB > &&std::is_same_v< typename DerivedA::Scalar, Expression > &&std::is_same_v< typename DerivedB::Scalar, Expression >, bool >	CheckStructuralEquality (const DerivedA &m1, const DerivedB &m2)
	Checks if two Eigen::Matrix<Expression> m1 and m2 are structurally equal.
bool	is_integer (double v)
bool	is_positive_integer (double v)
bool	is_non_negative_integer (double v)
bool	is_variable (const ExpressionCell &c)
	Checks if c is a variable expression.
bool	is_unary (const ExpressionCell &c)
	Checks if c is a unary expression.
bool	is_binary (const ExpressionCell &c)
	Checks if c is a binary expression.
bool	is_addition (const ExpressionCell &c)
	Checks if c is an addition expression.
bool	is_multiplication (const ExpressionCell &c)
	Checks if c is an multiplication expression.
bool	is_division (const ExpressionCell &c)
	Checks if c is a division expression.
bool	is_log (const ExpressionCell &c)
	Checks if c is a log expression.
bool	is_abs (const ExpressionCell &c)
	Checks if c is an absolute-value-function expression.
bool	is_exp (const ExpressionCell &c)
	Checks if c is an exp expression.
bool	is_sqrt (const ExpressionCell &c)
	Checks if c is a square-root expression.
bool	is_pow (const ExpressionCell &c)
	Checks if c is a power-function expression.
bool	is_sin (const ExpressionCell &c)
	Checks if c is a sine expression.
bool	is_cos (const ExpressionCell &c)
	Checks if c is a cosine expression.
bool	is_tan (const ExpressionCell &c)
	Checks if c is a tangent expression.
bool	is_asin (const ExpressionCell &c)
	Checks if c is an arcsine expression.
bool	is_acos (const ExpressionCell &c)
	Checks if c is an arccosine expression.
bool	is_atan (const ExpressionCell &c)
	Checks if c is an arctangent expression.
bool	is_atan2 (const ExpressionCell &c)
	Checks if c is a arctangent2 expression.
bool	is_sinh (const ExpressionCell &c)
	Checks if c is a hyperbolic-sine expression.
bool	is_cosh (const ExpressionCell &c)
	Checks if c is a hyperbolic-cosine expression.
bool	is_tanh (const ExpressionCell &c)
	Checks if c is a hyperbolic-tangent expression.
bool	is_min (const ExpressionCell &c)
	Checks if c is a min expression.
bool	is_max (const ExpressionCell &c)
	Checks if c is a max expression.
bool	is_ceil (const ExpressionCell &c)
	Checks if c is a ceil expression.
bool	is_floor (const ExpressionCell &c)
	Checks if c is a floor expression.
bool	is_if_then_else (const ExpressionCell &c)
	Checks if c is an if-then-else expression.
bool	is_uninterpreted_function (const ExpressionCell &c)
	Checks if c is an uninterpreted-function expression.
bool	operator< (ExpressionKind k1, ExpressionKind k2)
	Total ordering between ExpressionKinds.
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.
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.
bool	operator< (FormulaKind k1, FormulaKind k2)
Formula	forall (const Variables &vars, const Formula &f)
	Returns a formula f, universally quantified by variables vars.
Formula	make_conjunction (const std::set< Formula > &formulas)
	Returns a conjunction of formulas.
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.
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)
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.
Formula	isinf (const Expression &e)
	Returns a Formula determining if the given expression e is a positive or negative infinity.
Formula	isfinite (const Expression &e)
	Returns a Formula determining if the given expression e has a finite value.
Formula	positive_semidefinite (const Eigen::Ref< const MatrixX< Expression > > &m)
	Returns a symbolic formula constraining m to be a positive-semidefinite matrix.
Formula	positive_semidefinite (const MatrixX< Expression > &m, Eigen::UpLoType mode)
	Constructs and returns a symbolic positive-semidefinite formula from m.
template<typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Derived::Scalar, Expression >, Formula >	positive_semidefinite (const Eigen::TriangularView< Derived, Eigen::Lower > &l)
	Constructs and returns a symbolic positive-semidefinite formula from a lower triangular-view l.
template<typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Derived::Scalar, Expression >, Formula >	positive_semidefinite (const Eigen::TriangularView< Derived, Eigen::Upper > &u)
	Constructs and returns a symbolic positive-semidefinite formula from an upper triangular-view u.
std::ostream &	operator<< (std::ostream &os, const Formula &f)
bool	is_false (const Formula &f)
	Checks if f is structurally equal to False formula.
bool	is_true (const Formula &f)
	Checks if f is structurally equal to True formula.
bool	is_variable (const Formula &f)
	Checks if f is a variable formula.
bool	is_equal_to (const Formula &f)
	Checks if f is a formula representing equality (==).
bool	is_not_equal_to (const Formula &f)
	Checks if f is a formula representing disequality (!=).
bool	is_greater_than (const Formula &f)
	Checks if f is a formula representing greater-than (>).
bool	is_greater_than_or_equal_to (const Formula &f)
	Checks if f is a formula representing greater-than-or-equal-to (>=).
bool	is_less_than (const Formula &f)
	Checks if f is a formula representing less-than (<).
bool	is_less_than_or_equal_to (const Formula &f)
	Checks if f is a formula representing less-than-or-equal-to (<=).
bool	is_relational (const Formula &f)
	Checks if f is a relational formula ({==, !=, >, >=, <, <=}).
bool	is_conjunction (const Formula &f)
	Checks if f is a conjunction (∧).
bool	is_disjunction (const Formula &f)
	Checks if f is a disjunction (∨).
bool	is_nary (const Formula &f)
	Checks if f is a n-ary formula ({∧, ∨}).
bool	is_negation (const Formula &f)
	Checks if f is a negation (¬).
bool	is_forall (const Formula &f)
	Checks if f is a Forall formula (∀).
bool	is_isnan (const Formula &f)
	Checks if f is an isnan formula.
bool	is_positive_semidefinite (const Formula &f)
	Checks if f is a positive-semidefinite formula.
const Variable &	get_variable (const Formula &f)
	Returns the embedded variable in the variable formula f.
const Expression &	get_lhs_expression (const Formula &f)
	Returns the lhs-argument of a relational formula f.
const Expression &	get_rhs_expression (const Formula &f)
	Returns the rhs-argument of a relational formula f.
const Expression &	get_unary_expression (const Formula &f)
	Returns the expression in a unary expression formula f.
const std::set< Formula > &	get_operands (const Formula &f)
	Returns the set of formulas in a n-ary formula f.
const Formula &	get_operand (const Formula &f)
	Returns the formula in a negation formula f.
const Variables &	get_quantified_variables (const Formula &f)
	Returns the quantified variables in a forall formula f.
const Formula &	get_quantified_formula (const Formula &f)
	Returns the quantified formula in a forall formula f.
const MatrixX< Expression > &	get_matrix_in_positive_semidefinite (const Formula &f)
	Returns the matrix in a positive-semidefinite formula f.
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()==typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >	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.
template<typename Derived, typename ScalarType>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar()==ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (==).
template<typename ScalarType, typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType()==typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (==).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()<=typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >	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 (<=).
template<typename Derived, typename ScalarType>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar()<=ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (<=).
template<typename ScalarType, typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType()<=typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (<=).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()< typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >	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 (<).
template<typename Derived, typename ScalarType>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar()< ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (<).
template<typename ScalarType, typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType()< typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (<).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() >=typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >	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 (>=).
template<typename Derived, typename ScalarType>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar() >=ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (>=).
template<typename ScalarType, typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType() >=typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (>=).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() > typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >	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 (>).
template<typename Derived, typename ScalarType>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar() > ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (>).
template<typename ScalarType, typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType() > typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (>).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() !=typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType >	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 (!=).
template<typename Derived, typename ScalarType>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar() !=ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (!=).
template<typename ScalarType, typename Derived>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType() !=typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > >	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 (!=).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()==typename DerivedB::Scalar()), Formula >, Formula >	operator== (const DerivedA &m1, const DerivedB &m2)
	Returns a symbolic formula checking if two matrices m1 and m2 are equal.
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() !=typename DerivedB::Scalar()), Formula >, Formula >	operator!= (const DerivedA &m1, const DerivedB &m2)
	Returns a symbolic formula representing the condition whether m1 and m2 are not the same.
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()< typename DerivedB::Scalar()), Formula >, Formula >	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.
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()<=typename DerivedB::Scalar()), Formula >, Formula >	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 (<=).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() > typename DerivedB::Scalar()), Formula >, Formula >	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 (>).
template<typename DerivedA, typename DerivedB>
std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() >=typename DerivedB::Scalar()), Formula >, Formula >	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 (>=).
bool	is_false (const FormulaCell &f)
	Checks if f is structurally equal to False formula.
bool	is_true (const FormulaCell &f)
	Checks if f is structurally equal to True formula.
bool	is_variable (const FormulaCell &f)
	Checks if f is a variable formula.
bool	is_equal_to (const FormulaCell &f)
	Checks if f is a formula representing equality (==).
bool	is_not_equal_to (const FormulaCell &f)
	Checks if f is a formula representing disequality (!=).
bool	is_greater_than (const FormulaCell &f)
	Checks if f is a formula representing greater-than (>).
bool	is_greater_than_or_equal_to (const FormulaCell &f)
	Checks if f is a formula representing greater-than-or-equal-to (>=).
bool	is_less_than (const FormulaCell &f)
	Checks if f is a formula representing less-than (<).
bool	is_less_than_or_equal_to (const FormulaCell &f)
	Checks if f is a formula representing less-than-or-equal-to (<=).
bool	is_relational (const FormulaCell &f)
	Checks if f is a relational formula ({==, !=, >, >=, <, <=}).
bool	is_conjunction (const FormulaCell &f)
	Checks if f is a conjunction (∧).
bool	is_disjunction (const FormulaCell &f)
	Checks if f is a disjunction (∨).
bool	is_nary (const FormulaCell &f)
	Checks if f is N-ary.
bool	is_negation (const FormulaCell &f)
	Checks if f is a negation (¬).
bool	is_forall (const FormulaCell &f)
	Checks if f is a Forall formula (∀).
bool	is_isnan (const FormulaCell &f)
	Checks if f is an isnan formula.
bool	is_positive_semidefinite (const FormulaCell &f)
	Checks if f is a positive semidefinite formula.
std::shared_ptr< const FormulaFalse >	to_false (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaFalse>.
std::shared_ptr< const FormulaTrue >	to_true (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaTrue>.
std::shared_ptr< const FormulaVar >	to_variable (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaVar>.
std::shared_ptr< const RelationalFormulaCell >	to_relational (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const RelationalFormulaCell>.
std::shared_ptr< const FormulaEq >	to_equal_to (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaEq>.
std::shared_ptr< const FormulaNeq >	to_not_equal_to (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaNeq>.
std::shared_ptr< const FormulaGt >	to_greater_than (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaGt>.
std::shared_ptr< const FormulaGeq >	to_greater_than_or_equal_to (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaGeq>.
std::shared_ptr< const FormulaLt >	to_less_than (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaLt>.
std::shared_ptr< const FormulaLeq >	to_less_than_or_equal_to (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaLeq>.
std::shared_ptr< const FormulaAnd >	to_conjunction (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaAnd>.
std::shared_ptr< const FormulaOr >	to_disjunction (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaOr>.
std::shared_ptr< const NaryFormulaCell >	to_nary (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const NaryFormulaCell>.
std::shared_ptr< const FormulaNot >	to_negation (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaNot>.
std::shared_ptr< const FormulaForall >	to_forall (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaForall>.
std::shared_ptr< const FormulaIsnan >	to_isnan (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaIsnan>.
std::shared_ptr< const FormulaPositiveSemidefinite >	to_positive_semidefinite (const std::shared_ptr< const FormulaCell > &f_ptr)
	Casts f_ptr to shared_ptr<const FormulaPositiveSemidefinite>.
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.
std::ostream &	operator<< (std::ostream &os, Variable::Type type)
MatrixX< Variable >	MakeMatrixVariable (int rows, int cols, const std::string &name, Variable::Type type=Variable::Type::CONTINUOUS)
	Creates a dynamically-sized Eigen matrix of symbolic variables.
MatrixX< Variable >	MakeMatrixBooleanVariable (int rows, int cols, const std::string &name)
	Creates a dynamically-sized Eigen matrix of symbolic Boolean variables.
MatrixX< Variable >	MakeMatrixBinaryVariable (int rows, int cols, const std::string &name)
	Creates a dynamically-sized Eigen matrix of symbolic binary variables.
MatrixX< Variable >	MakeMatrixContinuousVariable (int rows, int cols, const std::string &name)
	Creates a dynamically-sized Eigen matrix of symbolic continuous variables.
MatrixX< Variable >	MakeMatrixIntegerVariable (int rows, int cols, const std::string &name)
	Creates a dynamically-sized Eigen matrix of symbolic integer variables.
template<int rows, int cols>
Eigen::Matrix< Variable, rows, cols >	MakeMatrixVariable (const std::string &name, Variable::Type type=Variable::Type::CONTINUOUS)
	Creates a static-sized Eigen matrix of symbolic variables.
template<int rows, int cols>
Eigen::Matrix< Variable, rows, cols >	MakeMatrixBooleanVariable (const std::string &name)
	Creates a static-sized Eigen matrix of symbolic Boolean variables.
template<int rows, int cols>
Eigen::Matrix< Variable, rows, cols >	MakeMatrixBinaryVariable (const std::string &name)
	Creates a static-sized Eigen matrix of symbolic binary variables.
template<int rows, int cols>
Eigen::Matrix< Variable, rows, cols >	MakeMatrixContinuousVariable (const std::string &name)
	Creates a static-sized Eigen matrix of symbolic continuous variables.
template<int rows, int cols>
Eigen::Matrix< Variable, rows, cols >	MakeMatrixIntegerVariable (const std::string &name)
	Creates a static-sized Eigen matrix of symbolic integer variables.
VectorX< Variable >	MakeVectorVariable (int rows, const std::string &name, Variable::Type type=Variable::Type::CONTINUOUS)
	Creates a dynamically-sized Eigen vector of symbolic variables.
VectorX< Variable >	MakeVectorBooleanVariable (int rows, const std::string &name)
	Creates a dynamically-sized Eigen vector of symbolic Boolean variables.
VectorX< Variable >	MakeVectorBinaryVariable (int rows, const std::string &name)
	Creates a dynamically-sized Eigen vector of symbolic binary variables.
VectorX< Variable >	MakeVectorContinuousVariable (int rows, const std::string &name)
	Creates a dynamically-sized Eigen vector of symbolic continuous variables.
VectorX< Variable >	MakeVectorIntegerVariable (int rows, const std::string &name)
	Creates a dynamically-sized Eigen vector of symbolic integer variables.
template<int rows>
Eigen::Matrix< Variable, rows, 1 >	MakeVectorVariable (const std::string &name, Variable::Type type=Variable::Type::CONTINUOUS)
	Creates a static-sized Eigen vector of symbolic variables.
template<int rows>
Eigen::Matrix< Variable, rows, 1 >	MakeVectorBooleanVariable (const std::string &name)
	Creates a static-sized Eigen vector of symbolic Boolean variables.
template<int rows>
Eigen::Matrix< Variable, rows, 1 >	MakeVectorBinaryVariable (const std::string &name)
	Creates a static-sized Eigen vector of symbolic binary variables.
template<int rows>
Eigen::Matrix< Variable, rows, 1 >	MakeVectorContinuousVariable (const std::string &name)
	Creates a static-sized Eigen vector of symbolic continuous variables.
template<int rows>
Eigen::Matrix< Variable, rows, 1 >	MakeVectorIntegerVariable (const std::string &name)
	Creates a static-sized Eigen vector of symbolic integer variables.
template<typename DerivedA, typename DerivedB>
std::enable_if_t< is_eigen_scalar_same< DerivedA, Variable >::value &&is_eigen_scalar_same< DerivedB, Variable >::value, bool >	CheckStructuralEquality (const DerivedA &m1, const DerivedB &m2)
	Checks if two Eigen::Matrix<Variable> m1 and m2 are structurally equal.
Variables &	operator+= (Variables &vars1, const Variables &vars2)
	Updates var1 with the result of set-union(var1, var2).
Variables &	operator+= (Variables &vars, const Variable &var)
	Updates vars with the result of set-union(vars, { var }).
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.
Variables &	operator-= (Variables &vars1, const Variables &vars2)
	Updates var1 with the result of set-minus(var1, var2).
Variables &	operator-= (Variables &vars, const Variable &var)
	Updates vars with the result of set-minus(vars, {var}).
Variables	operator- (Variables vars1, const Variables &vars2)
	Returns set-minus(var1, vars2).
Variables	operator- (Variables vars, const Variable &var)
	Returns set-minus(vars, { var }).
Variables	intersect (const Variables &vars1, const Variables &vars2)
	Returns the intersection of vars1 and vars2.
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (const GenericPolynomial< BasisElement > &p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (GenericPolynomial< BasisElement > p1, const GenericPolynomial< BasisElement > &p2)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (GenericPolynomial< BasisElement > p, const BasisElement &m)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (GenericPolynomial< BasisElement > p, double c)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (const BasisElement &m, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (const BasisElement &m1, const BasisElement &m2)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (const BasisElement &m, double c)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (double c, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (double c, const BasisElement &m)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (GenericPolynomial< BasisElement > p, const Variable &v)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator+ (const Variable &v, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (GenericPolynomial< BasisElement > p1, const GenericPolynomial< BasisElement > &p2)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (GenericPolynomial< BasisElement > p, const BasisElement &m)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (GenericPolynomial< BasisElement > p, double c)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (const BasisElement &m, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (const BasisElement &m1, const BasisElement &m2)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (const BasisElement &m, double c)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (double c, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (double c, const BasisElement &m)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (GenericPolynomial< BasisElement > p, const Variable &v)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator- (const Variable &v, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (GenericPolynomial< BasisElement > p1, const GenericPolynomial< BasisElement > &p2)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (GenericPolynomial< BasisElement > p, const BasisElement &m)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (GenericPolynomial< BasisElement > p, double c)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (const BasisElement &m, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (const BasisElement &m, double c)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (double c, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (double c, const BasisElement &m)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (GenericPolynomial< BasisElement > p, const Variable &v)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator* (const Variable &v, GenericPolynomial< BasisElement > p)
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	operator/ (GenericPolynomial< BasisElement > p, double v)
	Returns p / v.
template<typename BasisElement>
GenericPolynomialEnable< BasisElement >	pow (const GenericPolynomial< BasisElement > &p, int n)
	Returns polynomial raised to n.
template<typename BasisElement>
std::ostream &	operator<< (std::ostream &os, const GenericPolynomial< BasisElement > &p)
std::string	ToLatex (const Expression &e, int precision=3)
	Generates a LaTeX string representation of e with floating point coefficients displayed using precision.
std::string	ToLatex (const Formula &f, int precision=3)
	Generates a LaTeX string representation of f with floating point coefficients displayed using precision.
std::string	ToLatex (double val, int precision=3)
	Generates a Latex string representation of val displayed with precision, with one exception.
template<typename Derived>
std::string	ToLatex (const Eigen::PlainObjectBase< Derived > &M, int precision=3)
	Generates a LaTeX string representation of M with floating point coefficients displayed using precision.
std::ostream &	operator<< (std::ostream &out, const Monomial &m)
Monomial	operator* (Monomial m1, const Monomial &m2)
	Returns a multiplication of two monomials, m1 and m2.
Monomial	pow (Monomial m, int p)
	Returns m raised to p.
std::ostream &	operator<< (std::ostream &out, const MonomialBasisElement &m)
std::map< MonomialBasisElement, double >	operator* (const MonomialBasisElement &m1, const MonomialBasisElement &m2)
	Returns a multiplication of two monomials, m1 and m2.
std::map< MonomialBasisElement, double >	pow (MonomialBasisElement m, int p)
	Returns m raised to p.
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.
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.
VectorX< Monomial >	MonomialBasis (const std::unordered_map< Variables, int > &variables_degree)
	Returns all the monomials (in graded reverse lexicographic order) such that the total degree for each set of variables is no larger than a specific degree.
Eigen::Matrix< Monomial, Eigen::Dynamic, 1 >	EvenDegreeMonomialBasis (const Variables &vars, int degree)
	Returns all even degree monomials up to a given degree under the graded reverse lexicographic order.
Eigen::Matrix< Monomial, Eigen::Dynamic, 1 >	OddDegreeMonomialBasis (const Variables &vars, int degree)
	Returns all odd degree monomials up to a given degree under the graded reverse lexicographic order.
VectorX< Monomial >	CalcMonomialBasisOrderUpToOne (const Variables &x, bool sort_monomial=false)
	Generates all the monomials of x, such that the degree for x(i) is no larger than 1 for every x(i) in x.
Polynomial	operator- (const Polynomial &p)
	Unary minus operation for polynomial.
Polynomial	operator+ (Polynomial p1, const Polynomial &p2)
Polynomial	operator+ (Polynomial p, const Monomial &m)
Polynomial	operator+ (Polynomial p, double c)
Polynomial	operator+ (const Monomial &m, Polynomial p)
Polynomial	operator+ (const Monomial &m1, const Monomial &m2)
Polynomial	operator+ (const Monomial &m, double c)
Polynomial	operator+ (double c, Polynomial p)
Polynomial	operator+ (double c, const Monomial &m)
Polynomial	operator+ (Polynomial p, const Variable &v)
Polynomial	operator+ (const Variable &v, Polynomial p)
Expression	operator+ (const Expression &e, const Polynomial &p)
Expression	operator+ (const Polynomial &p, const Expression &e)
Polynomial	operator- (Polynomial p1, const Polynomial &p2)
Polynomial	operator- (Polynomial p, const Monomial &m)
Polynomial	operator- (Polynomial p, double c)
Polynomial	operator- (const Monomial &m, Polynomial p)
Polynomial	operator- (const Monomial &m1, const Monomial &m2)
Polynomial	operator- (const Monomial &m, double c)
Polynomial	operator- (double c, Polynomial p)
Polynomial	operator- (double c, const Monomial &m)
Polynomial	operator- (Polynomial p, const Variable &v)
Polynomial	operator- (const Variable &v, const Polynomial &p)
Expression	operator- (const Expression &e, const Polynomial &p)
Expression	operator- (const Polynomial &p, const Expression &e)
Polynomial	operator* (Polynomial p1, const Polynomial &p2)
Polynomial	operator* (Polynomial p, const Monomial &m)
Polynomial	operator* (Polynomial p, double c)
Polynomial	operator* (const Monomial &m, Polynomial p)
Polynomial	operator* (const Monomial &m, double c)
Polynomial	operator* (double c, Polynomial p)
Polynomial	operator* (double c, const Monomial &m)
Polynomial	operator* (Polynomial p, const Variable &v)
Polynomial	operator* (const Variable &v, Polynomial p)
Expression	operator* (const Expression &e, const Polynomial &p)
Expression	operator* (const Polynomial &p, const Expression &e)
Polynomial	operator/ (Polynomial p, double v)
	Returns p / v.
Expression	operator/ (double v, const Polynomial &p)
Expression	operator/ (const Expression &e, const Polynomial &p)
Expression	operator/ (const Polynomial &p, const Expression &e)
Polynomial	pow (const Polynomial &p, int n)
	Returns polynomial p raised to n.
std::ostream &	operator<< (std::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 matrix operations:
template<typename Derived>
std::enable_if_t< std::is_same_v< typename Derived::Scalar, Polynomial >, MatrixLikewise< double, Derived > >	Evaluate (const Eigen::MatrixBase< Derived > &m, const Environment &env)
	Evaluates a matrix m of symbolic polynomials using env.
MatrixX< Polynomial >	Jacobian (const Eigen::Ref< const VectorX< Polynomial > > &f, const Eigen::Ref< const VectorX< Variable > > &vars)
	Computes the Jacobian matrix J of the vector function f with respect to vars.
template<typename Derived1, typename Derived2>
std::enable_if< is_eigen_vector_of< Derived1, symbolic::Monomial >::value &&(is_eigen_vector_of< Derived2, double >::value||is_eigen_vector_of< Derived2, symbolic::Variable >::value||is_eigen_vector_of< Derived2, symbolic::Expression >::value), symbolic::Polynomial >::type	CalcPolynomialWLowerTriangularPart (const Eigen::MatrixBase< Derived1 > &monomial_basis, const Eigen::MatrixBase< Derived2 > &gram_lower)
	Returns the polynomial m(x)ᵀ * Q * m(x), where m(x) is the monomial basis, and Q is the Gram matrix.
template<int rows, typename BasisElement>
Eigen::Matrix< BasisElement, rows, 1 >	ComputePolynomialBasisUpToDegree (const Variables &vars, int degree, internal::DegreeType degree_type)
	Returns all polynomial basis elements up to a given degree under the graded reverse lexicographic order.
RationalFunction	operator+ (RationalFunction f1, const RationalFunction &f2)
RationalFunction	operator+ (RationalFunction f, const Polynomial &p)
RationalFunction	operator+ (const Polynomial &p, RationalFunction f)
RationalFunction	operator+ (const Monomial &m, RationalFunction f)
RationalFunction	operator+ (RationalFunction f, const Monomial &m)
RationalFunction	operator+ (RationalFunction f, double c)
RationalFunction	operator+ (double c, RationalFunction f)
RationalFunction	operator- (RationalFunction f1, const RationalFunction &f2)
RationalFunction	operator- (RationalFunction f, const Polynomial &p)
RationalFunction	operator- (const Polynomial &p, const RationalFunction &f)
RationalFunction	operator- (RationalFunction f, double c)
RationalFunction	operator- (double c, RationalFunction f)
RationalFunction	operator- (const Monomial &m, RationalFunction f)
RationalFunction	operator- (RationalFunction f, const Monomial &m)
RationalFunction	operator* (RationalFunction f1, const RationalFunction &f2)
RationalFunction	operator* (RationalFunction f, const Polynomial &p)
RationalFunction	operator* (const Polynomial &p, RationalFunction f)
RationalFunction	operator* (RationalFunction f, double c)
RationalFunction	operator* (double c, RationalFunction f)
RationalFunction	operator* (const Monomial &m, RationalFunction f)
RationalFunction	operator* (RationalFunction f, const Monomial &m)
RationalFunction	operator/ (RationalFunction f1, const RationalFunction &f2)
RationalFunction	operator/ (RationalFunction f, const Polynomial &p)
RationalFunction	operator/ (const Polynomial &p, const RationalFunction &f)
RationalFunction	operator/ (RationalFunction f, double c)
RationalFunction	operator/ (double c, const RationalFunction &f)
RationalFunction	operator/ (const Monomial &m, RationalFunction f)
RationalFunction	operator/ (RationalFunction f, const Monomial &m)
RationalFunction	pow (const RationalFunction &f, int n)
	Returns the rational function f raised to n.
template<typename MatrixL, typename MatrixR>
Eigen::Matrix< RationalFunction, MatrixL::RowsAtCompileTime, MatrixR::ColsAtCompileTime >	operator* (const MatrixL &lhs, const MatrixR &rhs)
	Provides the following operations:
symbolic::Expression	ReplaceBilinearTerms (const symbolic::Expression &e, const Eigen::Ref< const VectorX< symbolic::Variable > > &x, const Eigen::Ref< const VectorX< symbolic::Variable > > &y, const Eigen::Ref< const MatrixX< symbolic::Expression > > &W)
	Replaces all the bilinear product terms in the expression e, with the corresponding terms in W, where W represents the matrix x * yᵀ, such that after replacement, e does not have bilinear terms involving x and y.
Rewriter	MakeRuleRewriter (const RewritingRule &r)
	Constructs a rewriter based on a rewriting rule r.
Expression	Substitute (const Expression &e, const SinCosSubstitution &subs)
	Given a substitution map q => {s, c}, substitutes instances of sin(q) and cos(q) in e with s and c, with partial support for trigonometric expansions.
template<typename Derived>
MatrixLikewise< Expression, Derived >	Substitute (const Eigen::MatrixBase< Derived > &m, const SinCosSubstitution &subs)
	Matrix version of sin/cos substitution.
symbolic::RationalFunction	SubstituteStereographicProjection (const symbolic::Polynomial &e, const std::vector< SinCos > &sin_cos, const VectorX< symbolic::Variable > &t)
	Substitutes the variables representing sine and cosine functions with their stereographic projection.

Typedef Documentation

GenericPolynomialEnable

template<typename BasisElement>

using GenericPolynomialEnable

Initial value:

 
    std::enable_if_t<std::is_base_of_v<PolynomialBasisElement, BasisElement>,
                     GenericPolynomial<BasisElement>>

Defines an explicit SFINAE alias for use with return types to dissuade CTAD from trying to instantiate an invalid GenericElement<> for operator overloads, (if that's actually the case).

See discussion for more info: https://github.com/robotlocomotion/drake/pull/14053#pullrequestreview-488744679

Pattern

using Pattern = Expression

A pattern is an expression which possibly includes variables which represent placeholders.

It is used to construct a RewritingRule.

Rewriter

using Rewriter = std::function<Expression(const Expression&)>

A Rewriter is a function from an Expression to an Expression.

SinCosSubstitution

using SinCosSubstitution = std::unordered_map<Variable, SinCos>

Substitution

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

Enumeration Type Documentation

ExpressionKind

enum class ExpressionKind : std::uint16_t

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.

FormulaKind

enum class 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.

SinCosSubstitutionType

enum class SinCosSubstitutionType

strong

Enumerator
kAngle	Substitutes s <=> sin(q), c <=> cos(q).
kHalfAnglePreferSin	Substitutes s <=> sin(q/2), c <=> cos(q/2), and prefers sin when the choice is ambiguous; e.g. cos(q) => 1 - 2s².
kHalfAnglePreferCos	Substitutes s <=> sin(q/2), c <=> cos(q/2), and prefers cos when the choice is ambiguous; e.g. cos(q) => 2c² - 1.

Function Documentation

abs()

Expression abs

(

const Expression &

e

)

acos()

Expression acos

(

const Expression &

e

)

asin()

Expression asin

(

const Expression &

e

)

atan()

Expression atan

(

const Expression &

e

)

atan2()

Expression atan2	(	const Expression &	e1,
		const Expression &	e2 )

CalcMonomialBasisOrderUpToOne()

VectorX< Monomial > CalcMonomialBasisOrderUpToOne ( const Variables & x, bool sort_monomial = false )

nodiscard

Generates all the monomials of x, such that the degree for x(i) is no larger than 1 for every x(i) in x.

Parameters

x	The variables whose monomials are generated.
sort_monomial	If true, the returned monomials are sorted in the graded reverse lexicographic order. For example if x = (x₀, x₁) with x₀< x₁, then this function returns [x₀x₁, x₁, x₀, 1]. If sort_monomial=false, then we return the monomials in an arbitrary order.

CalcPolynomialWLowerTriangularPart()

template<typename Derived1, typename Derived2>

std::enable_if< is_eigen_vector_of< Derived1, symbolic::Monomial >::value &&(is_eigen_vector_of< Derived2, double >::value||is_eigen_vector_of< Derived2, symbolic::Variable >::value||is_eigen_vector_of< Derived2, symbolic::Expression >::value), symbolic::Polynomial >::type CalcPolynomialWLowerTriangularPart ( const Eigen::MatrixBase< Derived1 > & monomial_basis, const Eigen::MatrixBase< Derived2 > & gram_lower )

nodiscard

Returns the polynomial m(x)ᵀ * Q * m(x), where m(x) is the monomial basis, and Q is the Gram matrix.

Parameters

monomial_basis	m(x) in the documentation. A vector of monomials.
gram_lower	The lower triangular entries in Q, stacked columnwise into a vector.

ceil()

Expression ceil

(

const Expression &

e

)

CheckStructuralEquality() [1/2]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< DerivedA >, DerivedA > &&std::is_base_of_v< Eigen::MatrixBase< DerivedB >, DerivedB > &&std::is_same_v< typename DerivedA::Scalar, Expression > &&std::is_same_v< typename DerivedB::Scalar, Expression >, bool > 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.

CheckStructuralEquality() [2/2]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< is_eigen_scalar_same< DerivedA, Variable >::value &&is_eigen_scalar_same< DerivedB, Variable >::value, bool > 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.

clamp()

Expression clamp	(	const Expression &	v,
		const Expression &	lo,
		const Expression &	hi )

ComputePolynomialBasisUpToDegree()

template<int rows, typename BasisElement>

Eigen::Matrix< BasisElement, rows, 1 > ComputePolynomialBasisUpToDegree	(	const Variables &	vars,
		int	degree,
		internal::DegreeType	degree_type )

Returns all polynomial basis elements up to a given degree under the graded reverse lexicographic order.

Template Parameters

rows	Number of rows or Eigen::Dynamic.
BasisElement	A derived class of PolynomialBasisElement.

Parameters

vars	The variables appearing in the polynomial basis.
degree	The highest total degree of the polynomial basis elements.
degree_type	If degree_type is kAny, then the polynomial basis elements' degrees are no larger than degree. If degree_type is kEven, then the elements' degrees are even numbers no larger than degree. If degree_type is kOdd, then the elements' degrees are odd numbers no larger than degree. TODO(hongkai.dai): this will replace ComputeMonomialBasis in monomial_util.h.

cos()

Expression cos

(

const Expression &

e

)

cosh()

Expression cosh

(

const Expression &

e

)

DecomposeAffineExpression()

int DecomposeAffineExpression	(	const symbolic::Expression &	e,
		const std::unordered_map< symbolic::Variable::Id, int > &	map_var_to_index,
		EigenPtr< Eigen::RowVectorXd >	coeffs,
		double *	constant_term )

Decomposes an affine combination e = c0 + c1 * v1 + ... cn * vn into the following:

 constant term      : c0
 coefficient vector : [c1, ..., cn]
 variable vector    : [v1, ..., vn]

Then, it extracts the coefficient and the constant term. A map from variable ID to int, map_var_to_index, is used to decide a variable's index in a linear combination.

Precondition

1. coeffs is a row vector of double, whose length matches with the size of map_var_to_index.
2. e.is_polynomial() is true.
3. e is an affine expression.
4. all values in map_var_to_index should be in the range [0, map_var_to_index.size())

Parameters

[in]	e	The symbolic affine expression
[in]	map_var_to_index	A mapping from variable ID to variable index, such that map_var_to_index[vi.get_ID()] = i.
[out]	coeffs	A row vector. coeffs(i) = ci.
[out]	constant_term	c0 in the equation above.

Returns

num_variable. Number of variables in the expression. 2 * x(0) + 3 has 1 variable; 2 * x(0) + 3 * x(1) - 2 * x(0) has 1 variable, since the x(0) term cancels.

Exceptions

std::exception

if the input expression is not affine.

DecomposeAffineExpressions() [1/2]

void DecomposeAffineExpressions	(	const Eigen::Ref< const VectorX< Expression > > &	expressions,
		const Eigen::Ref< const VectorX< Variable > > &	vars,
		EigenPtr< Eigen::MatrixXd >	M,
		EigenPtr< Eigen::VectorXd >	v )

Decomposes expressions into M * vars + v.

Exceptions

std::exception

if expressions is not affine in vars.

Precondition

M.rows() == expressions.rows() && M.cols() == vars.rows().

v.rows() == expressions.rows().

DecomposeAffineExpressions() [2/2]

void DecomposeAffineExpressions	(	const Eigen::Ref< const VectorX< symbolic::Expression > > &	v,
		Eigen::MatrixXd *	A,
		Eigen::VectorXd *	b,
		VectorX< Variable > *	vars )

Given a vector of affine expressions v, decompose it to \( v = A vars + b \).

Parameters

[in]	v	A vector of affine expressions
[out]	A	The matrix containing the linear coefficients.
[out]	b	The vector containing all the constant terms.
[out]	vars	All variables.

Exceptions

std::exception

if the input expressions are not affine.

DecomposeL2NormExpression()

std::tuple< bool, Eigen::MatrixXd, Eigen::VectorXd, VectorX< Variable > > DecomposeL2NormExpression	(	const symbolic::Expression &	e,
		double	psd_tol = 1e-8,
		double	coefficient_tol = 1e-8 )

Decomposes an L2 norm e = |Ax+b|₂ into A, b, and the variable vector x (or returns false if the decomposition is not possible).

In order for the decomposition to succeed, the following conditions must be met:

1. e is a sqrt expression.
2. e.get_argument() is a polynomial of degree 2, which can be expressed as a quadratic form (Ax+b)ᵀ(Ax+b).

Parameters

e	The symbolic affine expression
psd_tol	The tolerance for checking positive semidefiniteness. Eigenvalues less that this threshold are considered to be zero. Matrices with negative eigenvalues less than this threshold are considered to be not positive semidefinite, and will cause the decomposition to fail.
coefficient_tol	The absolute tolerance for checking that the coefficients of the expression inside the sqrt match the coefficients of |Ax+b|₂².

Returns

[is_l2norm, A, b, vars] where is_l2norm is true iff the decomposition was successful, and if is_l2norm is true then |A*vars + b|₂ = e.

DecomposeLinearExpressions()

void DecomposeLinearExpressions	(	const Eigen::Ref< const VectorX< Expression > > &	expressions,
		const Eigen::Ref< const VectorX< Variable > > &	vars,
		EigenPtr< Eigen::MatrixXd >	M )

Decomposes expressions into M * vars.

Exceptions

std::exception

if expressions is not linear in vars.

Precondition

M.rows() == expressions.rows() && M.cols() == vars.rows().

DecomposeLumpedParameters()

std::tuple< MatrixX< Expression >, VectorX< Expression >, VectorX< Expression > > DecomposeLumpedParameters	(	const Eigen::Ref< const VectorX< Expression > > &	f,
		const Eigen::Ref< const VectorX< Variable > > &	parameters )

Given a vector of Expressions f and a list of parameters we define all additional variables in f to be a vector of "non-parameter variables", n.

This method returns a factorization of f into an equivalent "data matrix", W, which depends only on the non-parameter variables, and a "lumped parameter vector", α, which depends only on parameters: f = W(n)*α(parameters) + w0(n).

Note

The current implementation makes some simple attempts to minimize the number of lumped parameters, but more simplification could be implemented relatively easily. Optimal simplification, however, involves the complexity of comparing two arbitrary Expressions (see Expression::EqualTo for more details).

Exceptions

std::exception

if f is not decomposable in this way (cells containing parameters may only be added or multiplied with cells containing non-parameter variables).

Returns

W(n), α(parameters), and w0(n).

DecomposeQuadraticPolynomial()

void DecomposeQuadraticPolynomial	(	const symbolic::Polynomial &	poly,
		const std::unordered_map< symbolic::Variable::Id, int > &	map_var_to_index,
		Eigen::MatrixXd *	Q,
		Eigen::VectorXd *	b,
		double *	c )

Given a quadratic polynomial poly, decomposes it into the form 0.5 * x' Q * x + b' * x + c.

Parameters

[in]	poly	Quadratic polynomial to decompose.
[in]	map_var_to_index	maps variables in poly.GetVariables() to the index in the vector x.
[out]	Q	The Hessian of the quadratic expression.

Precondition

The size of Q should be num_variables x num_variables. Q is a symmetric matrix.

Parameters

[out]

b

linear term of the quadratic expression.

Precondition

The size of b should be num_variables.

Parameters

[out]

c

The constant term of the quadratic expression.

Evaluate() [1/3]

template<typename Derived>

std::enable_if_t< std::is_same_v< typename Derived::Scalar, Polynomial >, MatrixLikewise< double, Derived > > Evaluate ( const Eigen::MatrixBase< Derived > & m, const Environment & env )

nodiscard

Evaluates a matrix m of symbolic polynomials using env.

Returns

a matrix of double whose size is the size of m.

Exceptions

std::exception

if NaN is detected during evaluation.

Evaluate() [2/3]

template<typename Derived>

std::enable_if_t< std::is_same_v< typename Derived::Scalar, Expression >, MatrixLikewise< double, Derived > > Evaluate	(	const Eigen::MatrixBase< Derived > &	m,
		const Environment &	env = Environment{},
		RandomGenerator *	random_generator = nullptr )

Evaluates a symbolic matrix m using env and random_generator.

If there is a random variable in m which is unassigned in env, this function uses random_generator to sample a value and use the value to substitute all occurrences of the random variable in m.

Returns

a matrix of double whose size is the size of m.

Exceptions

std::exception	if NaN is detected during evaluation.
std::exception	if m includes unassigned random variables but random_generator is nullptr.

Evaluate() [3/3]

Eigen::SparseMatrix< double > Evaluate	(	const Eigen::Ref< const Eigen::SparseMatrix< Expression > > &	m,
		const Environment &	env = Environment{} )

Evaluates m using a given environment (by default, an empty environment).

Exceptions

std::exception	if there exists a variable in m whose value is not provided by env.
std::exception	if NaN is detected during evaluation.

EvaluateChebyshevPolynomial()

double EvaluateChebyshevPolynomial	(	double	var_val,
		int	degree )

Evaluates a Chebyshev polynomial at a given value.

Parameters

var_val	The value of the variable.
degree	The degree of the Chebyshev polynomial.

EvenDegreeMonomialBasis()

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

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

A monomial has an even degree if its total degree is even. So xy is an even degree monomial (degree 2) while x²y is not (degree 3). 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, EvenDegreeMonomialBasis({x, y, z}, 2) returns a column vector [x², xy, y², xz, yz, z², 1].

Precondition

vars is a non-empty set.

degree is a non-negative integer.

exp()

Expression exp

(

const Expression &

e

)

ExtractAndAppendVariablesFromExpression()

void ExtractAndAppendVariablesFromExpression	(	const symbolic::Expression &	e,
		std::vector< Variable > *	vars,
		std::unordered_map< symbolic::Variable::Id, int > *	map_var_to_index )

Given an expression e, extracts all variables inside e, appends these variables to vars if they are not included in vars yet.

Parameters

[in]	e	A symbolic expression.
[in,out]	vars	As an input, vars contain the variables before extracting expression e. As an output, the variables in e that were not included in vars, will be appended to the end of vars.
[in,out]	map_var_to_index	is of the same size as vars, and map_var_to_index[vars(i).get_id()] = i. This invariance holds for map_var_to_index both as the input and as the output.

ExtractVariablesFromExpression() [1/2]

std::pair< VectorX< Variable >, std::unordered_map< Variable::Id, int > > ExtractVariablesFromExpression

(

const Eigen::Ref< const VectorX< Expression > > &

expressions

)

Overloads ExtractVariablesFromExpression but with a vector of expressions.

ExtractVariablesFromExpression() [2/2]

std::pair< VectorX< Variable >, std::unordered_map< symbolic::Variable::Id, int > > ExtractVariablesFromExpression

(

const symbolic::Expression &

e

)

Given an expression e, extracts all variables inside e.

Parameters

[in]

e

A symbolic expression.

Return values

pair	pair.first is the variables in e. pair.second is the mapping from the variable ID to the index in pair.first, such that pair.second[pair.first(i).get_id()] = i

floor()

Expression floor

(

const Expression &

e

)

forall()

Formula forall	(	const Variables &	vars,
		const Formula &	f )

Returns a formula f, universally quantified by variables vars.

get_argument()

const Expression & get_argument

(

const Expression &

e

)

Returns the argument in the unary expression e.

Precondition

{e is a unary expression.}

get_base_to_exponent_map_in_multiplication()

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.}

get_conditional_formula()

const Formula & get_conditional_formula

(

const Expression &

e

)

Returns the conditional formula in the if-then-else expression e.

Precondition

e is an if-then-else expression.

get_constant_in_addition()

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.}

get_constant_in_multiplication()

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.}

get_constant_value()

double get_constant_value

(

const Expression &

e

)

Returns the constant value of the constant expression e.

Precondition

{e is a constant expression.}

get_else_expression()

const Expression & get_else_expression

(

const Expression &

e

)

Returns the 'else' expression in the if-then-else expression e.

Precondition

e is an if-then-else expression.

get_expr_to_coeff_map_in_addition()

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.}

get_first_argument()

const Expression & get_first_argument

(

const Expression &

e

)

Returns the first argument of the binary expression e.

Precondition

{e is a binary expression.}

get_lhs_expression()

const Expression & get_lhs_expression

(

const Formula &

f

)

Returns the lhs-argument of a relational formula f.

Precondition

{f is a relational formula.}

get_matrix_in_positive_semidefinite()

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.}

get_operand()

const Formula & get_operand

(

const Formula &

f

)

Returns the formula in a negation formula f.

Precondition

{f is a negation formula.}

get_operands()

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.}

get_quantified_formula()

const Formula & get_quantified_formula

(

const Formula &

f

)

Returns the quantified formula in a forall formula f.

Precondition

{f is a forall formula.}

get_quantified_variables()

const Variables & get_quantified_variables

(

const Formula &

f

)

Returns the quantified variables in a forall formula f.

Precondition

{f is a forall formula.}

get_rhs_expression()

const Expression & get_rhs_expression

(

const Formula &

f

)

Returns the rhs-argument of a relational formula f.

Precondition

{f is a relational formula.}

get_second_argument()

const Expression & get_second_argument

(

const Expression &

e

)

Returns the second argument of the binary expression e.

Precondition

{e is a binary expression.}

get_then_expression()

const Expression & get_then_expression

(

const Expression &

e

)

Returns the 'then' expression in the if-then-else expression e.

Precondition

e is an if-then-else expression.

get_unary_expression()

const Expression & get_unary_expression

(

const Formula &

f

)

Returns the expression in a unary expression formula f.

Currently, an isnan() formula is the only kind of unary expression formula.

Precondition

{f is a unary expression formula.}

get_uninterpreted_function_arguments()

const std::vector< Expression > & get_uninterpreted_function_arguments

(

const Expression &

e

)

Returns the arguments of an uninterpreted-function expression e.

Precondition

e is an uninterpreted-function expression.

get_uninterpreted_function_name()

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.

get_variable() [1/2]

const Variable & get_variable

(

const Expression &

e

)

Returns the embedded variable in the variable expression e.

Precondition

{e is a variable expression.}

get_variable() [2/2]

const Variable & get_variable

(

const Formula &

f

)

Returns the embedded variable in the variable formula f.

Precondition

f is a variable formula.

GetDistinctVariables()

Variables GetDistinctVariables

(

const Eigen::Ref< const MatrixX< Expression > > &

v

)

Returns the distinct variables in the matrix of expressions.

GetVariableVector()

VectorX< Variable > GetVariableVector

(

const Eigen::Ref< const VectorX< Expression > > &

expressions

)

Constructs a vector of variables from the vector of variable expressions.

Exceptions

std::exception

if there is an expression in vec which is not a variable.

if_then_else()

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.

intersect()

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.

is_abs() [1/2]

bool is_abs

(

const Expression &

e

)

Checks if e is an abs expression.

is_abs() [2/2]

bool is_abs

(

const ExpressionCell &

c

)

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

is_acos() [1/2]

bool is_acos

(

const Expression &

e

)

Checks if e is an arccosine expression.

is_acos() [2/2]

bool is_acos

(

const ExpressionCell &

c

)

Checks if c is an arccosine expression.

is_addition() [1/2]

bool is_addition

(

const Expression &

e

)

Checks if e is an addition expression.

is_addition() [2/2]

bool is_addition

(

const ExpressionCell &

c

)

Checks if c is an addition expression.

is_asin() [1/2]

bool is_asin

(

const Expression &

e

)

Checks if e is an arcsine expression.

is_asin() [2/2]

bool is_asin

(

const ExpressionCell &

c

)

Checks if c is an arcsine expression.

is_atan() [1/2]

bool is_atan

(

const Expression &

e

)

Checks if e is an arctangent expression.

is_atan() [2/2]

bool is_atan

(

const ExpressionCell &

c

)

Checks if c is an arctangent expression.

is_atan2() [1/2]

bool is_atan2

(

const Expression &

e

)

Checks if e is an arctangent2 expression.

is_atan2() [2/2]

bool is_atan2

(

const ExpressionCell &

c

)

Checks if c is a arctangent2 expression.

is_binary()

bool is_binary

(

const ExpressionCell &

c

)

Checks if c is a binary expression.

is_ceil() [1/2]

bool is_ceil

(

const Expression &

e

)

Checks if e is a ceil expression.

is_ceil() [2/2]

bool is_ceil

(

const ExpressionCell &

c

)

Checks if c is a ceil expression.

is_conjunction() [1/2]

bool is_conjunction

(

const Formula &

f

)

Checks if f is a conjunction (∧).

is_conjunction() [2/2]

bool is_conjunction

(

const FormulaCell &

f

)

Checks if f is a conjunction (∧).

is_constant() [1/2]

bool is_constant

(

const Expression &

e

)

Checks if e is a constant expression.

is_constant() [2/2]

bool is_constant	(	const Expression &	e,
		double	v )

Checks if e is a constant expression representing v.

is_cos() [1/2]

bool is_cos

(

const Expression &

e

)

Checks if e is a cosine expression.

is_cos() [2/2]

bool is_cos

(

const ExpressionCell &

c

)

Checks if c is a cosine expression.

is_cosh() [1/2]

bool is_cosh

(

const Expression &

e

)

Checks if e is a hyperbolic-cosine expression.

is_cosh() [2/2]

bool is_cosh

(

const ExpressionCell &

c

)

Checks if c is a hyperbolic-cosine expression.

is_disjunction() [1/2]

bool is_disjunction

(

const Formula &

f

)

Checks if f is a disjunction (∨).

is_disjunction() [2/2]

bool is_disjunction

(

const FormulaCell &

f

)

Checks if f is a disjunction (∨).

is_division() [1/2]

bool is_division

(

const Expression &

e

)

Checks if e is a division expression.

is_division() [2/2]

bool is_division

(

const ExpressionCell &

c

)

Checks if c is a division expression.

is_equal_to() [1/2]

bool is_equal_to

(

const Formula &

f

)

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

is_equal_to() [2/2]

bool is_equal_to

(

const FormulaCell &

f

)

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

is_exp() [1/2]

bool is_exp

(

const Expression &

e

)

Checks if e is an exp expression.

is_exp() [2/2]

bool is_exp

(

const ExpressionCell &

c

)

Checks if c is an exp expression.

is_false() [1/2]

bool is_false

(

const Formula &

f

)

Checks if f is structurally equal to False formula.

is_false() [2/2]

bool is_false

(

const FormulaCell &

f

)

Checks if f is structurally equal to False formula.

is_floor() [1/2]

bool is_floor

(

const Expression &

e

)

Checks if e is a floor expression.

is_floor() [2/2]

bool is_floor

(

const ExpressionCell &

c

)

Checks if c is a floor expression.

is_forall() [1/2]

bool is_forall

(

const Formula &

f

)

Checks if f is a Forall formula (∀).

is_forall() [2/2]

bool is_forall

(

const FormulaCell &

f

)

Checks if f is a Forall formula (∀).

is_greater_than() [1/2]

bool is_greater_than

(

const Formula &

f

)

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

is_greater_than() [2/2]

bool is_greater_than

(

const FormulaCell &

f

)

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

is_greater_than_or_equal_to() [1/2]

bool is_greater_than_or_equal_to

(

const Formula &

f

)

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

is_greater_than_or_equal_to() [2/2]

bool is_greater_than_or_equal_to

(

const FormulaCell &

f

)

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

is_if_then_else() [1/2]

bool is_if_then_else

(

const Expression &

e

)

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

is_if_then_else() [2/2]

bool is_if_then_else

(

const ExpressionCell &

c

)

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

is_integer()

bool is_integer

(

double

v

)

is_isnan() [1/2]

bool is_isnan

(

const Formula &

f

)

Checks if f is an isnan formula.

is_isnan() [2/2]

bool is_isnan

(

const FormulaCell &

f

)

Checks if f is an isnan formula.

is_less_than() [1/2]

bool is_less_than

(

const Formula &

f

)

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

is_less_than() [2/2]

bool is_less_than

(

const FormulaCell &

f

)

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

is_less_than_or_equal_to() [1/2]

bool is_less_than_or_equal_to

(

const Formula &

f

)

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

is_less_than_or_equal_to() [2/2]

bool is_less_than_or_equal_to

(

const FormulaCell &

f

)

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

is_log() [1/2]

bool is_log

(

const Expression &

e

)

Checks if e is a log expression.

is_log() [2/2]

bool is_log

(

const ExpressionCell &

c

)

Checks if c is a log expression.

is_max() [1/2]

bool is_max

(

const Expression &

e

)

Checks if e is a max expression.

is_max() [2/2]

bool is_max

(

const ExpressionCell &

c

)

Checks if c is a max expression.

is_min() [1/2]

bool is_min

(

const Expression &

e

)

Checks if e is a min expression.

is_min() [2/2]

bool is_min

(

const ExpressionCell &

c

)

Checks if c is a min expression.

is_multiplication() [1/2]

bool is_multiplication

(

const Expression &

e

)

Checks if e is a multiplication expression.

is_multiplication() [2/2]

bool is_multiplication

(

const ExpressionCell &

c

)

Checks if c is an multiplication expression.

is_nan()

bool is_nan

(

const Expression &

e

)

Checks if e is NaN.

is_nary() [1/2]

bool is_nary

(

const Formula &

f

)

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

is_nary() [2/2]

bool is_nary

(

const FormulaCell &

f

)

Checks if f is N-ary.

is_neg_one()

bool is_neg_one

(

const Expression &

e

)

Checks if e is -1.0.

is_negation() [1/2]

bool is_negation

(

const Formula &

f

)

Checks if f is a negation (¬).

is_negation() [2/2]

bool is_negation

(

const FormulaCell &

f

)

Checks if f is a negation (¬).

is_non_negative_integer()

bool is_non_negative_integer

(

double

v

)

is_not_equal_to() [1/2]

bool is_not_equal_to

(

const Formula &

f

)

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

is_not_equal_to() [2/2]

bool is_not_equal_to

(

const FormulaCell &

f

)

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

is_one()

bool is_one

(

const Expression &

e

)

Checks if e is 1.0.

is_positive_integer()

bool is_positive_integer

(

double

v

)

is_positive_semidefinite() [1/2]

bool is_positive_semidefinite

(

const Formula &

f

)

Checks if f is a positive-semidefinite formula.

is_positive_semidefinite() [2/2]

bool is_positive_semidefinite

(

const FormulaCell &

f

)

Checks if f is a positive semidefinite formula.

is_pow() [1/2]

bool is_pow

(

const Expression &

e

)

Checks if e is a power-function expression.

is_pow() [2/2]

bool is_pow

(

const ExpressionCell &

c

)

Checks if c is a power-function expression.

is_relational() [1/2]

bool is_relational

(

const Formula &

f

)

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

is_relational() [2/2]

bool is_relational

(

const FormulaCell &

f

)

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

is_sin() [1/2]

bool is_sin

(

const Expression &

e

)

Checks if e is a sine expression.

is_sin() [2/2]

bool is_sin

(

const ExpressionCell &

c

)

Checks if c is a sine expression.

is_sinh() [1/2]

bool is_sinh

(

const Expression &

e

)

Checks if e is a hyperbolic-sine expression.

is_sinh() [2/2]

bool is_sinh

(

const ExpressionCell &

c

)

Checks if c is a hyperbolic-sine expression.

is_sqrt() [1/2]

bool is_sqrt

(

const Expression &

e

)

Checks if e is a square-root expression.

is_sqrt() [2/2]

bool is_sqrt

(

const ExpressionCell &

c

)

Checks if c is a square-root expression.

is_tan() [1/2]

bool is_tan

(

const Expression &

e

)

Checks if e is a tangent expression.

is_tan() [2/2]

bool is_tan

(

const ExpressionCell &

c

)

Checks if c is a tangent expression.

is_tanh() [1/2]

bool is_tanh

(

const Expression &

e

)

Checks if e is a hyperbolic-tangent expression.

is_tanh() [2/2]

bool is_tanh

(

const ExpressionCell &

c

)

Checks if c is a hyperbolic-tangent expression.

is_true() [1/2]

bool is_true

(

const Formula &

f

)

Checks if f is structurally equal to True formula.

is_true() [2/2]

bool is_true

(

const FormulaCell &

f

)

Checks if f is structurally equal to True formula.

is_two()

bool is_two

(

const Expression &

e

)

Checks if e is 2.0.

is_unary()

bool is_unary

(

const ExpressionCell &

c

)

Checks if c is a unary expression.

is_uninterpreted_function() [1/2]

bool is_uninterpreted_function

(

const Expression &

e

)

Checks if e is an uninterpreted-function expression.

is_uninterpreted_function() [2/2]

bool is_uninterpreted_function

(

const ExpressionCell &

c

)

Checks if c is an uninterpreted-function expression.

is_variable() [1/4]

bool is_variable

(

const Expression &

e

)

Checks if e is a variable expression.

is_variable() [2/4]

bool is_variable

(

const ExpressionCell &

c

)

Checks if c is a variable expression.

is_variable() [3/4]

bool is_variable

(

const Formula &

f

)

Checks if f is a variable formula.

is_variable() [4/4]

bool is_variable

(

const FormulaCell &

f

)

Checks if f is a variable formula.

is_zero()

bool is_zero

(

const Expression &

e

)

Checks if e is 0.0.

IsAffine() [1/2]

bool IsAffine

(

const Eigen::Ref< const MatrixX< Expression > > &

m

)

Checks if every element in m is affine.

Note

If m is an empty matrix, it returns true.

IsAffine() [2/2]

bool IsAffine	(	const Eigen::Ref< const MatrixX< Expression > > &	m,
		const Variables &	vars )

Checks if every element in m is affine in vars.

Note

If m is an empty matrix, it returns true.

isfinite()

Formula isfinite

(

const Expression &

e

)

Returns a Formula determining if the given expression e has a finite value.

Exceptions

std::exception

if NaN is detected during evaluation.

isinf()

Formula isinf

(

const Expression &

e

)

Returns a Formula determining if the given expression e is a positive or negative infinity.

Exceptions

std::exception

if NaN is detected during evaluation.

isnan()

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 this formula is evaluated, there are two possible outcomes:

• Returns false if the e.Evaluate() is not NaN.
• Throws std::exception if NaN is detected during evaluation. Note that the evaluation of isnan(e) never returns true.

Jacobian() [1/3]

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}.

Jacobian() [2/3]

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}.

Jacobian() [3/3]

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

nodiscard

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.

log()

Expression log

(

const Expression &

e

)

make_conjunction()

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₃.

make_disjunction()

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₃.

MakeMatrixBinaryVariable() [1/2]

template<int rows, int cols>

Eigen::Matrix< Variable, rows, cols > MakeMatrixBinaryVariable

(

const std::string &

name

)

Creates a static-sized Eigen matrix of symbolic binary variables.

Template Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.

Parameters

name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixBinaryVariable() [2/2]

MatrixX< Variable > MakeMatrixBinaryVariable	(	int	rows,
		int	cols,
		const std::string &	name )

Creates a dynamically-sized Eigen matrix of symbolic binary variables.

Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.
name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixBooleanVariable() [1/2]

template<int rows, int cols>

Eigen::Matrix< Variable, rows, cols > MakeMatrixBooleanVariable

(

const std::string &

name

)

Creates a static-sized Eigen matrix of symbolic Boolean variables.

Template Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.

Parameters

name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixBooleanVariable() [2/2]

MatrixX< Variable > MakeMatrixBooleanVariable	(	int	rows,
		int	cols,
		const std::string &	name )

Creates a dynamically-sized Eigen matrix of symbolic Boolean variables.

Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.
name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixContinuousVariable() [1/2]

template<int rows, int cols>

Eigen::Matrix< Variable, rows, cols > MakeMatrixContinuousVariable

(

const std::string &

name

)

Creates a static-sized Eigen matrix of symbolic continuous variables.

Template Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.

Parameters

name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixContinuousVariable() [2/2]

MatrixX< Variable > MakeMatrixContinuousVariable	(	int	rows,
		int	cols,
		const std::string &	name )

Creates a dynamically-sized Eigen matrix of symbolic continuous variables.

Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.
name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixIntegerVariable() [1/2]

template<int rows, int cols>

Eigen::Matrix< Variable, rows, cols > MakeMatrixIntegerVariable

(

const std::string &

name

)

Creates a static-sized Eigen matrix of symbolic integer variables.

Template Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.

Parameters

name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixIntegerVariable() [2/2]

MatrixX< Variable > MakeMatrixIntegerVariable	(	int	rows,
		int	cols,
		const std::string &	name )

Creates a dynamically-sized Eigen matrix of symbolic integer variables.

Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.
name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).

MakeMatrixVariable() [1/2]

template<int rows, int cols>

Eigen::Matrix< Variable, rows, cols > MakeMatrixVariable	(	const std::string &	name,
		Variable::Type	type = Variable::Type::CONTINUOUS )

Creates a static-sized Eigen matrix of symbolic variables.

Template Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.

Parameters

name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).
type	The type of variables in the matrix.

MakeMatrixVariable() [2/2]

MatrixX< Variable > MakeMatrixVariable	(	int	rows,
		int	cols,
		const std::string &	name,
		Variable::Type	type = Variable::Type::CONTINUOUS )

Creates a dynamically-sized Eigen matrix of symbolic variables.

Parameters

rows	The number of rows in the new matrix.
cols	The number of cols in the new matrix.
name	The common prefix for variables. The (i, j)-th element will be named as name(i, j).
type	The type of variables in the matrix.

MakeRuleRewriter()

Rewriter MakeRuleRewriter

(

const RewritingRule &

r

)

Constructs a rewriter based on a rewriting rule r.

MakeVectorBinaryVariable() [1/2]

template<int rows>

Eigen::Matrix< Variable, rows, 1 > MakeVectorBinaryVariable

(

const std::string &

name

)

Creates a static-sized Eigen vector of symbolic binary variables.

Template Parameters

rows	The size of vector.

Parameters

name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorBinaryVariable() [2/2]

VectorX< Variable > MakeVectorBinaryVariable	(	int	rows,
		const std::string &	name )

Creates a dynamically-sized Eigen vector of symbolic binary variables.

Parameters

rows	The size of vector.
name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorBooleanVariable() [1/2]

template<int rows>

Eigen::Matrix< Variable, rows, 1 > MakeVectorBooleanVariable

(

const std::string &

name

)

Creates a static-sized Eigen vector of symbolic Boolean variables.

Template Parameters

rows	The size of vector.

Parameters

name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorBooleanVariable() [2/2]

VectorX< Variable > MakeVectorBooleanVariable	(	int	rows,
		const std::string &	name )

Creates a dynamically-sized Eigen vector of symbolic Boolean variables.

Parameters

rows	The size of vector.
name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorContinuousVariable() [1/2]

template<int rows>

Eigen::Matrix< Variable, rows, 1 > MakeVectorContinuousVariable

(

const std::string &

name

)

Creates a static-sized Eigen vector of symbolic continuous variables.

Template Parameters

rows	The size of vector.

Parameters

name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorContinuousVariable() [2/2]

VectorX< Variable > MakeVectorContinuousVariable	(	int	rows,
		const std::string &	name )

Creates a dynamically-sized Eigen vector of symbolic continuous variables.

Parameters

rows	The size of vector.
name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorIntegerVariable() [1/2]

template<int rows>

Eigen::Matrix< Variable, rows, 1 > MakeVectorIntegerVariable

(

const std::string &

name

)

Creates a static-sized Eigen vector of symbolic integer variables.

Template Parameters

rows	The size of vector.

Parameters

name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorIntegerVariable() [2/2]

VectorX< Variable > MakeVectorIntegerVariable	(	int	rows,
		const std::string &	name )

Creates a dynamically-sized Eigen vector of symbolic integer variables.

Parameters

rows	The size of vector.
name	The common prefix for variables. The i-th element will be named as name(i).

MakeVectorVariable() [1/2]

template<int rows>

Eigen::Matrix< Variable, rows, 1 > MakeVectorVariable	(	const std::string &	name,
		Variable::Type	type = Variable::Type::CONTINUOUS )

Creates a static-sized Eigen vector of symbolic variables.

Template Parameters

rows	The size of vector.

Parameters

name	The common prefix for variables. The i-th element will be named as name(i).
type	The type of variables in the vector.

MakeVectorVariable() [2/2]

VectorX< Variable > MakeVectorVariable	(	int	rows,
		const std::string &	name,
		Variable::Type	type = Variable::Type::CONTINUOUS )

Creates a dynamically-sized Eigen vector of symbolic variables.

Parameters

rows	The size of vector.
name	The common prefix for variables. The i-th element will be named as name(i).
type	The type of variables in the vector.

max()

Expression max	(	const Expression &	e1,
		const Expression &	e2 )

min()

Expression min	(	const Expression &	e1,
		const Expression &	e2 )

MonomialBasis() [1/3]

VectorX< Monomial > MonomialBasis ( const std::unordered_map< Variables, int > & variables_degree )

nodiscard

Returns all the monomials (in graded reverse lexicographic order) such that the total degree for each set of variables is no larger than a specific degree.

For example if x_set = {x₀, x₁} and y_set = {y₀, y₁}, then MonomialBasis({{x_set, 2}, {y_set, 1}}) will include all the monomials, whose total degree of x_set is no larger than 2, and the total degree of y_set is no larger than 1. Hence it can include monomials such as x₀x₁y₀, but not x₀y₀y₁ because the total degree for y_set is 2. So it would return the following set of monomials (ignoring the ordering) {x₀²y₀, x₀²y₁, x₀x₁y₀, x₀x₁y₁, x₁²y₀, x₁²y₀, x₀y₀, x₀y₁, x₁y₀, x₁y₁, x₀², x₀x₁, x₁², x₀, x₁, y₀, y₁, 1}.

Parameters

variables_degree

(vars, degree) maps each set of variables vars to the maximal degree of these variables in the monomial. Namely the summation of the degree of each variable in vars is no larger than degree.

Precondition

The variables in variables_degree don't overlap.

The degree in variables_degree are non-negative.

MonomialBasis() [2/3]

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.

Template Parameters

n	number of variables.
degree	maximum total degree of monomials to compute.

Precondition

vars is a non-empty set.

vars.size() == n.

MonomialBasis() [3/3]

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.

NChooseK()

int NChooseK ( int n, int k )

constexpr

OddDegreeMonomialBasis()

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

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

A monomial has an odd degree if its total degree is odd. So x²y is an odd degree monomial (degree 3) while xy is not (degree 2). 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, OddDegreeMonomialBasis({x, y, z}, 3) returns a column vector [x³, x²y, xy², y³, x²z, xyz, y²z, xz², yz², z³, x, y, z]

Precondition

vars is a non-empty set.

degree is a non-negative integer.

operator!() [1/2]

Formula operator!

(

const Formula &

f

)

operator!() [2/2]

Formula operator!

(

const Variable &

v

)

operator!=() [1/5]

template<typename Derived, typename ScalarType>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar() !=ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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.

operator!=() [2/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() !=typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType > 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 (!=).

operator!=() [3/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() !=typename DerivedB::Scalar()), Formula >, Formula > operator!=	(	const DerivedA &	m1,
		const DerivedB &	m2 )

Returns a symbolic formula representing the condition whether m1 and m2 are not the same.

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>

operator!=() [4/5]

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

operator!=() [5/5]

template<typename ScalarType, typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType() !=typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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).

operator&&() [1/4]

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

operator&&() [2/4]

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

operator&&() [3/4]

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

operator&&() [4/4]

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

operator*() [1/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	const BasisElement &	m,
		double	c )

operator*() [2/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	const BasisElement &	m,
		GenericPolynomial< BasisElement >	p )

operator*() [3/43]

std::map< ChebyshevBasisElement, double > operator*	(	const ChebyshevBasisElement &	a,
		const ChebyshevBasisElement &	b )

Returns the product of two Chebyshev basis elements.

Since Tₘ(x) * Tₙ(x) = 0.5 (Tₘ₊ₙ(x) + Tₘ₋ₙ(x)) if m >= n, the product of Chebyshev basis elements is the weighted sum of several Chebyshev basis elements. For example T₁(x)T₂(y) * T₃(x)T₁(y) = 0.25*(T₄(x)T₃(y) + T₂(x)T₃(y)

• T₄(x)T₁(y) + T₂(x)T₁(y))

  Returns

  the result of the product, from each ChebyshevBasisElement to its coefficient. In the example above, it returns (T₄(x)T₃(y) -> 0.25), (T₂(x)T₃(y) -> 0.25), (T₄(x)T₁(y) -> 0.25) and (T₂(x)T₁(y) -> 0.25)

operator*() [4/43]

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>

operator*() [5/43]

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>

operator*() [6/43]

Expression operator* ( const Expression & e, const Polynomial & p )

nodiscard

operator*() [7/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Expression > &&std::is_same_v< typename MatrixR::Scalar, double >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [8/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, double > &&std::is_same_v< typename MatrixR::Scalar, Expression >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [9/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Expression > &&std::is_same_v< typename MatrixR::Scalar, Variable >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [10/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Variable > &&std::is_same_v< typename MatrixR::Scalar, Expression >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [11/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Variable > &&std::is_same_v< typename MatrixR::Scalar, double >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [12/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, double > &&std::is_same_v< typename MatrixR::Scalar, Variable >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [13/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Variable > &&std::is_same_v< typename MatrixR::Scalar, Variable >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [14/43]

template<typename MatrixL, typename MatrixR>

std::enable_if_t< std::is_base_of_v< Eigen::MatrixBase< MatrixL >, MatrixL > &&std::is_base_of_v< Eigen::MatrixBase< MatrixR >, MatrixR > &&std::is_same_v< typename MatrixL::Scalar, Expression > &&std::is_same_v< typename MatrixR::Scalar, Expression >, internal::ExpressionMatMulResult< MatrixL, MatrixR > > operator*	(	const MatrixL &	lhs,
		const MatrixR &	rhs )

Provides the following matrix operations:

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [15/43]

template<typename MatrixL, typename MatrixR>

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

Provides the following matrix operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [16/43]

template<typename MatrixL, typename MatrixR>

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

Provides the following operations:

• Matrix<RF> * Matrix<Polynomial> => Matrix<RF>
• Matrix<RF> * Matrix<double> => Matrix<RF>
• Matrix<Polynomial> * Matrix<RF> => Matrix<RF>
• Matrix<double> * Matrix<RF> => Matrix<RF>

where RF is a shorthand for RationalFunction.

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

Provides the following operations:

• Matrix<Polynomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Polynomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Monomial> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<Variable> => Matrix<Polynomial>
• Matrix<Monomial> * Matrix<double> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Polynomial> => Matrix<Polynomial>
• Matrix<Variable> * Matrix<Monomial> => 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.

• Matrix<Expression> * Matrix<Polynomial> => Matrix<Expression>
• Matrix<Expression> * Matrix<Monomial> => Matrix<Expression>
• Matrix<Polynomial> * Matrix<Expression> => Matrix<Expression>
• Matrix<Monomial> * Matrix<Expression> => Matrix<Expression>

  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.

operator*() [17/43]

Polynomial operator* ( const Monomial & m, double c )

nodiscard

operator*() [18/43]

Polynomial operator* ( const Monomial & m, Polynomial p )

nodiscard

operator*() [19/43]

RationalFunction operator*	(	const Monomial &	m,
		RationalFunction	f )

operator*() [20/43]

std::map< MonomialBasisElement, double > operator*	(	const MonomialBasisElement &	m1,
		const MonomialBasisElement &	m2 )

Returns a multiplication of two monomials, m1 and m2.

Note

that we return a map from the monomial product to its coefficient. This map has size 1, and the coefficient is also 1. We return a map instead of the MonomialBasisElement directly, because we want operator* to have the same return signature as other PolynomialBasisElement. For example, the product between two ChebyshevBasisElement objects is a weighted sum of ChebyshevBasisElement objects.

we do not provide operator*= function for this class, since operator*= would return MonomialBasisElement, which is different from operator*.

operator*() [21/43]

Expression operator* ( const Polynomial & p, const Expression & e )

nodiscard

operator*() [22/43]

RationalFunction operator*	(	const Polynomial &	p,
		RationalFunction	f )

operator*() [23/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	const Variable &	v,
		GenericPolynomial< BasisElement >	p )

operator*() [24/43]

Polynomial operator* ( const Variable & v, Polynomial p )

nodiscard

operator*() [25/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	double	c,
		const BasisElement &	m )

operator*() [26/43]

Polynomial operator* ( double c, const Monomial & m )

nodiscard

operator*() [27/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	double	c,
		GenericPolynomial< BasisElement >	p )

operator*() [28/43]

Polynomial operator* ( double c, Polynomial p )

nodiscard

operator*() [29/43]

RationalFunction operator*	(	double	c,
		RationalFunction	f )

operator*() [30/43]

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

operator*() [31/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	GenericPolynomial< BasisElement >	p,
		const BasisElement &	m )

operator*() [32/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	GenericPolynomial< BasisElement >	p,
		const Variable &	v )

operator*() [33/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	GenericPolynomial< BasisElement >	p,
		double	c )

operator*() [34/43]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator*	(	GenericPolynomial< BasisElement >	p1,
		const GenericPolynomial< BasisElement > &	p2 )

operator*() [35/43]

Monomial operator*	(	Monomial	m1,
		const Monomial &	m2 )

Returns a multiplication of two monomials, m1 and m2.

operator*() [36/43]

Polynomial operator* ( Polynomial p, const Monomial & m )

nodiscard

operator*() [37/43]

Polynomial operator* ( Polynomial p, const Variable & v )

nodiscard

operator*() [38/43]

Polynomial operator* ( Polynomial p, double c )

nodiscard

operator*() [39/43]

Polynomial operator* ( Polynomial p1, const Polynomial & p2 )

nodiscard

operator*() [40/43]

RationalFunction operator*	(	RationalFunction	f,
		const Monomial &	m )

operator*() [41/43]

RationalFunction operator*	(	RationalFunction	f,
		const Polynomial &	p )

operator*() [42/43]

RationalFunction operator*	(	RationalFunction	f,
		double	c )

operator*() [43/43]

RationalFunction operator*	(	RationalFunction	f1,
		const RationalFunction &	f2 )

operator*=()

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

operator+() [1/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	const BasisElement &	m,
		double	c )

operator+() [2/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	const BasisElement &	m,
		GenericPolynomial< BasisElement >	p )

operator+() [3/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	const BasisElement &	m1,
		const BasisElement &	m2 )

operator+() [4/35]

Expression operator+

(

const Expression &

e

)

operator+() [5/35]

Expression operator+ ( const Expression & e, const Polynomial & p )

nodiscard

operator+() [6/35]

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

nodiscard

operator+() [7/35]

Polynomial operator+ ( const Monomial & m, Polynomial p )

nodiscard

operator+() [8/35]

RationalFunction operator+	(	const Monomial &	m,
		RationalFunction	f )

operator+() [9/35]

Polynomial operator+ ( const Monomial & m1, const Monomial & m2 )

nodiscard

operator+() [10/35]

Expression operator+ ( const Polynomial & p, const Expression & e )

nodiscard

operator+() [11/35]

RationalFunction operator+	(	const Polynomial &	p,
		RationalFunction	f )

operator+() [12/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	const Variable &	v,
		GenericPolynomial< BasisElement >	p )

operator+() [13/35]

Polynomial operator+ ( const Variable & v, Polynomial p )

nodiscard

operator+() [14/35]

Expression operator+

(

const Variable &

var

)

operator+() [15/35]

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

Returns set-union of {var} and vars.

operator+() [16/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	double	c,
		const BasisElement &	m )

operator+() [17/35]

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

nodiscard

operator+() [18/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	double	c,
		GenericPolynomial< BasisElement >	p )

operator+() [19/35]

Polynomial operator+ ( double c, Polynomial p )

nodiscard

operator+() [20/35]

RationalFunction operator+	(	double	c,
		RationalFunction	f )

operator+() [21/35]

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

operator+() [22/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	GenericPolynomial< BasisElement >	p,
		const BasisElement &	m )

operator+() [23/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	GenericPolynomial< BasisElement >	p,
		const Variable &	v )

operator+() [24/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	GenericPolynomial< BasisElement >	p,
		double	c )

operator+() [25/35]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator+	(	GenericPolynomial< BasisElement >	p1,
		const GenericPolynomial< BasisElement > &	p2 )

operator+() [26/35]

Polynomial operator+ ( Polynomial p, const Monomial & m )

nodiscard

operator+() [27/35]

Polynomial operator+ ( Polynomial p, const Variable & v )

nodiscard

operator+() [28/35]

Polynomial operator+ ( Polynomial p, double c )

nodiscard

operator+() [29/35]

Polynomial operator+ ( Polynomial p1, const Polynomial & p2 )

nodiscard

operator+() [30/35]

RationalFunction operator+	(	RationalFunction	f,
		const Monomial &	m )

operator+() [31/35]

RationalFunction operator+	(	RationalFunction	f,
		const Polynomial &	p )

operator+() [32/35]

RationalFunction operator+	(	RationalFunction	f,
		double	c )

operator+() [33/35]

RationalFunction operator+	(	RationalFunction	f1,
		const RationalFunction &	f2 )

operator+() [34/35]

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

Returns set-union of vars and {var}.

operator+() [35/35]

Variables operator+	(	Variables	vars1,
		const Variables &	vars2 )

Returns set-union of var1 and var2.

operator+=() [1/3]

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

operator+=() [2/3]

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

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

operator+=() [3/3]

Variables & operator+=	(	Variables &	vars1,
		const Variables &	vars2 )

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

operator-() [1/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	const BasisElement &	m,
		double	c )

operator-() [2/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	const BasisElement &	m,
		GenericPolynomial< BasisElement >	p )

operator-() [3/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	const BasisElement &	m1,
		const BasisElement &	m2 )

operator-() [4/36]

Expression operator-

(

const Expression &

e

)

operator-() [5/36]

Expression operator- ( const Expression & e, const Polynomial & p )

nodiscard

operator-() [6/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-

(

const GenericPolynomial< BasisElement > &

p

)

operator-() [7/36]

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

nodiscard

operator-() [8/36]

Polynomial operator- ( const Monomial & m, Polynomial p )

nodiscard

operator-() [9/36]

RationalFunction operator-	(	const Monomial &	m,
		RationalFunction	f )

operator-() [10/36]

Polynomial operator- ( const Monomial & m1, const Monomial & m2 )

nodiscard

operator-() [11/36]

Polynomial operator- ( const Polynomial & p )

nodiscard

Unary minus operation for polynomial.

operator-() [12/36]

Expression operator- ( const Polynomial & p, const Expression & e )

nodiscard

operator-() [13/36]

RationalFunction operator-	(	const Polynomial &	p,
		const RationalFunction &	f )

operator-() [14/36]

Polynomial operator- ( const Variable & v, const Polynomial & p )

nodiscard

operator-() [15/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	const Variable &	v,
		GenericPolynomial< BasisElement >	p )

operator-() [16/36]

Expression operator-

(

const Variable &

var

)

operator-() [17/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	double	c,
		const BasisElement &	m )

operator-() [18/36]

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

nodiscard

operator-() [19/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	double	c,
		GenericPolynomial< BasisElement >	p )

operator-() [20/36]

Polynomial operator- ( double c, Polynomial p )

nodiscard

operator-() [21/36]

RationalFunction operator-	(	double	c,
		RationalFunction	f )

operator-() [22/36]

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

operator-() [23/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	GenericPolynomial< BasisElement >	p,
		const BasisElement &	m )

operator-() [24/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	GenericPolynomial< BasisElement >	p,
		const Variable &	v )

operator-() [25/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	GenericPolynomial< BasisElement >	p,
		double	c )

operator-() [26/36]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator-	(	GenericPolynomial< BasisElement >	p1,
		const GenericPolynomial< BasisElement > &	p2 )

operator-() [27/36]

Polynomial operator- ( Polynomial p, const Monomial & m )

nodiscard

operator-() [28/36]

Polynomial operator- ( Polynomial p, const Variable & v )

nodiscard

operator-() [29/36]

Polynomial operator- ( Polynomial p, double c )

nodiscard

operator-() [30/36]

Polynomial operator- ( Polynomial p1, const Polynomial & p2 )

nodiscard

operator-() [31/36]

RationalFunction operator-	(	RationalFunction	f,
		const Monomial &	m )

operator-() [32/36]

RationalFunction operator-	(	RationalFunction	f,
		const Polynomial &	p )

operator-() [33/36]

RationalFunction operator-	(	RationalFunction	f,
		double	c )

operator-() [34/36]

RationalFunction operator-	(	RationalFunction	f1,
		const RationalFunction &	f2 )

operator-() [35/36]

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

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

operator-() [36/36]

Variables operator-	(	Variables	vars1,
		const Variables &	vars2 )

Returns set-minus(var1, vars2).

operator-=() [1/3]

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

operator-=() [2/3]

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

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

operator-=() [3/3]

Variables & operator-=	(	Variables &	vars1,
		const Variables &	vars2 )

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

operator/() [1/13]

Expression operator/ ( const Expression & e, const Polynomial & p )

nodiscard

operator/() [2/13]

RationalFunction operator/	(	const Monomial &	m,
		RationalFunction	f )

operator/() [3/13]

Expression operator/ ( const Polynomial & p, const Expression & e )

nodiscard

operator/() [4/13]

RationalFunction operator/	(	const Polynomial &	p,
		const RationalFunction &	f )

Exceptions

std::exception

if the numerator of the divisor is structurally equal to zero. Note that this does not guarantee that the denominator of the result is not zero after expansion.

operator/() [5/13]

RationalFunction operator/	(	double	c,
		const RationalFunction &	f )

Exceptions

std::exception

if the numerator of the divisor is structurally equal to zero. Note that this does not guarantee that the denominator of the result is not zero after expansion.

operator/() [6/13]

Expression operator/ ( double v, const Polynomial & p )

nodiscard

operator/() [7/13]

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

operator/() [8/13]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > operator/	(	GenericPolynomial< BasisElement >	p,
		double	v )

Returns p / v.

operator/() [9/13]

Polynomial operator/ ( Polynomial p, double v )

nodiscard

Returns p / v.

operator/() [10/13]

RationalFunction operator/	(	RationalFunction	f,
		const Monomial &	m )

operator/() [11/13]

RationalFunction operator/	(	RationalFunction	f,
		const Polynomial &	p )

Exceptions

std::exception

if the divisor is structurally equal to zero. Note that this does not guarantee that the denominator of the result is not zero after expansion.

operator/() [12/13]

RationalFunction operator/	(	RationalFunction	f,
		double	c )

Exceptions

std::exception

if c is 0

operator/() [13/13]

RationalFunction operator/	(	RationalFunction	f1,
		const RationalFunction &	f2 )

Exceptions

std::exception

if the numerator of the divisor is structurally equal to zero. Note that this does not guarantee that the denominator of the result is not zero after expansion.

operator/=()

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

operator<() [1/7]

template<typename Derived, typename ScalarType>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar()< ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (<).

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

operator<() [2/7]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()< typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType > 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 (<).

operator<() [3/7]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()< typename DerivedB::Scalar()), Formula >, Formula > 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.

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	N/A

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

operator<() [4/7]

Formula operator<	(	const Expression &	e1,
		const Expression &	e2 )

operator<() [5/7]

template<typename ScalarType, typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType()< typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (<).

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

operator<() [6/7]

bool operator<	(	ExpressionKind	k1,
		ExpressionKind	k2 )

Total ordering between ExpressionKinds.

operator<() [7/7]

bool operator<	(	FormulaKind	k1,
		FormulaKind	k2 )

operator<<() [1/9]

std::ostream & operator<<	(	std::ostream &	os,
		const Expression &	e )

operator<<() [2/9]

std::ostream & operator<<	(	std::ostream &	os,
		const Formula &	f )

operator<<() [3/9]

template<typename BasisElement>

std::ostream & operator<<	(	std::ostream &	os,
		const GenericPolynomial< BasisElement > &	p )

operator<<() [4/9]

std::ostream & operator<<	(	std::ostream &	os,
		const Polynomial &	p )

operator<<() [5/9]

std::ostream & operator<<	(	std::ostream &	os,
		Variable::Type	type )

operator<<() [6/9]

std::ostream & operator<<	(	std::ostream &	out,
		const ChebyshevBasisElement &	m )

operator<<() [7/9]

std::ostream & operator<<	(	std::ostream &	out,
		const ChebyshevPolynomial &	p )

operator<<() [8/9]

std::ostream & operator<<	(	std::ostream &	out,
		const Monomial &	m )

operator<<() [9/9]

std::ostream & operator<<	(	std::ostream &	out,
		const MonomialBasisElement &	m )

operator<=() [1/5]

template<typename Derived, typename ScalarType>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar()<=ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (<=).

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

operator<=() [2/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()<=typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType > 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 (<=).

operator<=() [3/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()<=typename DerivedB::Scalar()), Formula >, Formula > 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 (<=).

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	N/A

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

operator<=() [4/5]

Formula operator<=	(	const Expression &	e1,
		const Expression &	e2 )

operator<=() [5/5]

template<typename ScalarType, typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType()<=typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (<=).

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

operator==() [1/5]

template<typename Derived, typename ScalarType>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar()==ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (==).

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

Here is an example using this operator overloading.
@code
    Eigen::Array<Variable, 2, 2> a;
    a << Variable{"x"}, Variable{"y"},
         Variable{"z"}, Variable{"w"};
    Eigen::Array<Formula, 2, 2> f = (a == 3.5);
    // Here f = |(x == 3.5)  (y == 3.5)|
    //          |(z == 3.5)  (w == 3.5)|.
@endcode 

operator==() [2/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()==typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType > 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.

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

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

In the table, EA is a short-hand of Eigen::Array.

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

• Eigen::Array<double> == Eigen::Array<double>

operator==() [3/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar()==typename DerivedB::Scalar()), Formula >, Formula > operator==	(	const DerivedA &	m1,
		const DerivedB &	m2 )

Returns a symbolic formula checking if two matrices m1 and m2 are equal.

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>

Note that this method returns a conjunctive formula which keeps its conjuncts as std::set<Formula> internally. This set is ordered by Formula::Less and this ordering can be different from the one in inputs. Also, any duplicated formulas are removed in construction. Please check the following example.

// set up v1 = [y x y] and v2 = [1 2 1]
VectorX<Expression> v1{3};
VectorX<Expression> v2{3};
const Variable x{"x"};
const Variable y{"y"};
v1 << y, x, y;
v2 << 1, 2, 1;
// Here v1_eq_v2 = ((x = 2) ∧ (y = 1))
const Formula v1_eq_v2{v1 == v2};
const std::set<Formula> conjuncts{get_operands(v1_eq_v2)};
for (const Formula& f : conjuncts) {
  std::cerr << f << std::endl;
}
// The outcome of the above loop is:
(x = 2)
(y = 1)

operator==() [4/5]

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

operator==() [5/5]

template<typename ScalarType, typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType()==typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (==).

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

Here is an example using this operator overloading.

Eigen::Array<Variable, 2, 2> a;
a << Variable{"x"}, Variable{"y"},
     Variable{"z"}, Variable{"w"};
Eigen::Array<Formula, 2, 2> f = (3.5 == a);
// Here f = |(3.5 == x)  (3.5 == y)|
//          |(3.5 == z)  (3.5 == w)|.

operator>() [1/5]

template<typename Derived, typename ScalarType>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar() > ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (>).

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

operator>() [2/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() > typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType > 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 (>).

operator>() [3/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() > typename DerivedB::Scalar()), Formula >, Formula > 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 (>).

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	N/A

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

operator>() [4/5]

Formula operator>	(	const Expression &	e1,
		const Expression &	e2 )

operator>() [5/5]

template<typename ScalarType, typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType() > typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (>).

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

Note that given `v > a`, this methods returns the result of `a < v`. First
of all, this formulation is mathematically equivalent to the original
formulation. We implement this method in this way to be consistent with
Eigen's semantics. See the definition of `EIGEN_MAKE_CWISE_COMP_R_OP` in
ArrayCwiseBinaryOps.h file in Eigen. 

operator>=() [1/5]

template<typename Derived, typename ScalarType>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename Derived::Scalar() >=ScalarType()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (>=).

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

operator>=() [2/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() >=typename DerivedB::Scalar()), Formula >, typename internal::RelationalOpTraits< DerivedA, DerivedB >::ReturnType > 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 (>=).

operator>=() [3/5]

template<typename DerivedA, typename DerivedB>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< DerivedA >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Eigen::internal::traits< DerivedB >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< decltype(typename DerivedA::Scalar() >=typename DerivedB::Scalar()), Formula >, Formula > 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 (>=).

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	N/A

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

operator>=() [4/5]

Formula operator>=	(	const Expression &	e1,
		const Expression &	e2 )

operator>=() [5/5]

template<typename ScalarType, typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::ArrayXpr > &&std::is_same_v< decltype(ScalarType() >=typename Derived::Scalar()), Formula >, Eigen::Array< Formula, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > > 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 (>=).

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

Note that given v >= a, this methods returns the result of a <= v. First of all, this formulation is mathematically equivalent to the original formulation. We implement this method in this way to be consistent with Eigen's semantics. See the definition of EIGEN_MAKE_CWISE_COMP_R_OP in ArrayCwiseBinaryOps.h file in Eigen.

operator||() [1/4]

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

operator||() [2/4]

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

operator||() [3/4]

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

operator||() [4/4]

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

PopulateRandomVariables()

Environment PopulateRandomVariables	(	Environment	env,
		const Variables &	variables,
		RandomGenerator *	random_generator )

Populates the environment env by sampling values for the unassigned random variables in variables using random_generator.

positive_semidefinite() [1/4]

Formula positive_semidefinite

(

const Eigen::Ref< const MatrixX< Expression > > &

m

)

Returns a symbolic formula constraining m to be a positive-semidefinite matrix.

By definition, a symmetric matrix m is positive-semidefinte if xᵀ m x ≥ 0 for all vector x ∈ ℝⁿ.

Exceptions

std::exception

if m is not symmetric.

Note

This method checks if m is symmetric, which can be costly. If you want to avoid it, please consider using positive_semidefinite(m.triangularView<Eigen::Lower>()) or positive_semidefinite(m.triangularView<Eigen::Upper>()) instead of positive_semidefinite(m).

positive_semidefinite() [2/4]

template<typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Derived::Scalar, Expression >, Formula > positive_semidefinite

(

const Eigen::TriangularView< Derived, Eigen::Lower > &

l

)

Constructs and returns a symbolic positive-semidefinite formula from a lower triangular-view l.

See the following code snippet.

Eigen::Matrix<Expression, 2, 2> m;
m << 1.0, 2.0,
     3.0, 4.0;
 
Formula psd{positive_semidefinite(m.triangularView<Eigen::Lower>())};
// psd includes [1.0 3.0]
//              [3.0 4.0].

positive_semidefinite() [3/4]

template<typename Derived>

std::enable_if_t< std::is_same_v< typename Eigen::internal::traits< Derived >::XprKind, Eigen::MatrixXpr > &&std::is_same_v< typename Derived::Scalar, Expression >, Formula > positive_semidefinite

(

const Eigen::TriangularView< Derived, Eigen::Upper > &

u

)

Constructs and returns a symbolic positive-semidefinite formula from an upper triangular-view u.

See the following code snippet.

Eigen::Matrix<Expression, 2, 2> m;
m << 1.0, 2.0,
     3.0, 4.0;
 
Formula psd{positive_semidefinite(m.triangularView<Eigen::Upper>())};
// psd includes [1.0 2.0]
//              [2.0 4.0].

positive_semidefinite() [4/4]

Formula positive_semidefinite	(	const MatrixX< Expression > &	m,
		Eigen::UpLoType	mode )

Constructs and returns a symbolic positive-semidefinite formula from m.

If mode is Eigen::Lower, it's using the lower-triangular part of m to construct a positive-semidefinite formula. If mode is Eigen::Upper, the upper-triangular part of m is used. It throws std::exception if has other values. See the following code snippet.

Eigen::Matrix<Expression, 2, 2> m;
m << 1.0, 2.0,
     3.0, 4.0;
 
const Formula psd_l{positive_semidefinite(m, Eigen::Lower)};
// psd_l includes [1.0 3.0]
//                [3.0 4.0].
 
const Formula psd_u{positive_semidefinite(m, Eigen::Upper)};
// psd_u includes [1.0 2.0]
//                [2.0 4.0].

pow() [1/6]

Expression pow	(	const Expression &	e1,
		const Expression &	e2 )

pow() [2/6]

template<typename BasisElement>

GenericPolynomialEnable< BasisElement > pow	(	const GenericPolynomial< BasisElement > &	p,
		int	n )

Returns polynomial raised to n.

Parameters

p	The base polynomial.
n	The exponent of the power.

Precondition

n>=0.

pow() [3/6]

Polynomial pow ( const Polynomial & p, int n )

nodiscard

Returns polynomial p raised to n.

pow() [4/6]

RationalFunction pow	(	const RationalFunction &	f,
		int	n )

Returns the rational function f raised to n.

If n is positive, (f/g)ⁿ = fⁿ / gⁿ; If n is negative, (f/g)ⁿ = g⁻ⁿ / f⁻ⁿ; (f/g)⁰ = 1 / 1.

pow() [5/6]

Monomial pow	(	Monomial	m,
		int	p )

Returns m raised to p.

Exceptions

std::exception

if p is negative.

pow() [6/6]

std::map< MonomialBasisElement, double > pow	(	MonomialBasisElement	m,
		int	p )

Returns m raised to p.

Note

that we return a map from the monomial power to its coefficient. This map has size 1, and the coefficient is also 1. We return a map instead of the MonomialBasisElement directly, because we want pow() to have the same return signature as other PolynomialBasisElement. For example, the power of a ChebyshevBasisElement object is a weighted sum of ChebyshevBasisElement objects.

Exceptions

std::exception

if p is negative.

ReplaceBilinearTerms()

symbolic::Expression ReplaceBilinearTerms	(	const symbolic::Expression &	e,
		const Eigen::Ref< const VectorX< symbolic::Variable > > &	x,
		const Eigen::Ref< const VectorX< symbolic::Variable > > &	y,
		const Eigen::Ref< const MatrixX< symbolic::Expression > > &	W )

Replaces all the bilinear product terms in the expression e, with the corresponding terms in W, where W represents the matrix x * yᵀ, such that after replacement, e does not have bilinear terms involving x and y.

For example, if e = x(0)*y(0) + 2 * x(0)*y(1) + x(1) * y(1) + 3 * x(1), e has bilinear terms x(0)*y(0), x(0) * y(1) and x(2) * y(1), if we call ReplaceBilinearTerms(e, x, y, W) where W(i, j) represent the term x(i) * y(j), then this function returns W(0, 0) + 2 * W(0, 1) + W(1, 1) + 3 * x(1).

Parameters

e	An expression potentially contains bilinear products between x and y.
x	The bilinear product between x and y will be replaced by the corresponding term in W.

Exceptions

std::exception

if x contains duplicate entries.

Parameters

y	The bilinear product between x and y will be replaced by the corresponding term in W.

Exceptions

std::exception

if y contains duplicate entries.

Parameters

W	Bilinear product term x(i) * y(j) will be replaced by W(i, j). If W(i,j) is not a single variable, but an expression, then this expression cannot contain a variable in either x or y.

Exceptions

std::exception,if

W(i, j) is not a single variable, and also contains a variable in x or y.

Precondition

W.rows() == x.rows() and W.cols() == y.rows().

Returns

The symbolic expression after replacing x(i) * y(j) with W(i, j).

sin()

Expression sin

(

const Expression &

e

)

sinh()

Expression sinh

(

const Expression &

e

)

sqrt()

Expression sqrt

(

const Expression &

e

)

Substitute() [1/4]

template<typename Derived>

MatrixLikewise< Expression, Derived > Substitute	(	const Eigen::MatrixBase< Derived > &	m,
		const SinCosSubstitution &	subs )

Matrix version of sin/cos substitution.

Substitute() [2/4]

template<typename Derived>

MatrixLikewise< Expression, Derived > Substitute	(	const Eigen::MatrixBase< Derived > &	m,
		const Substitution &	subst )

Substitutes a symbolic matrix m using a given substitution subst.

Returns

a matrix of symbolic expressions whose size is the size of m.

Exceptions

std::exception

if NaN is detected during substitution.

Substitute() [3/4]

template<typename Derived>

MatrixLikewise< Expression, Derived > Substitute	(	const Eigen::MatrixBase< Derived > &	m,
		const Variable &	var,
		const Expression &	e )

Substitutes var with e in a symbolic matrix m.

Returns

a matrix of symbolic expressions whose size is the size of m.

Exceptions

std::exception

if NaN is detected during substitution.

Substitute() [4/4]

Expression Substitute	(	const Expression &	e,
		const SinCosSubstitution &	subs )

Given a substitution map q => {s, c}, substitutes instances of sin(q) and cos(q) in e with s and c, with partial support for trigonometric expansions.

For instance,

  Variable x{"x"}, y{"y"};
  Variable sx{"sx"}, cx{"cx"}, sy{"sy"}, cy{"cy"};
  SinCosSubstitution subs;
  subs.emplace(x, SinCos(sx, cx));
  subs.emplace(y, SinCos(sy, cy));
  Expression e = Substitute(x * sin(x + y), subs);

will result in the expression x * (sx*cy + cx*sy).

Parameters

subs	When set to one of the half_angle options, then the same workflow replaces instances of sin(q/2) and cos(q/2) in e will be replaced with s, and c. Default: false.

The half-angle representation is more natural in many analysis computations for robots, for instance: https://underactuated.csail.mit.edu/lyapunov.html#trig_quadratic

Exceptions

std::exception

if a trigonometric function is not a trigonometric polynomial in q or if the e requires a trigonometric expansion that not supported yet.

SubstituteStereographicProjection()

symbolic::RationalFunction SubstituteStereographicProjection ( const symbolic::Polynomial & e, const std::vector< SinCos > & sin_cos, const VectorX< symbolic::Variable > & t )

nodiscard

Substitutes the variables representing sine and cosine functions with their stereographic projection.

We replace cosθᵢ with (1-tᵢ²)/(1+tᵢ²), and sinθᵢ with 2tᵢ/(1+tᵢ²), and get a rational polynomial. The indeterminates of this rational polynomial are t together with the indeterminates in e that are not cosθ or sinθ. If the input expression doesn't contain the sine and cosine functions, then the returned rational has denominator being 1. Notice that the indeterminates of e can include variables other than cosθ and sinθ, and we impose no requirements on these variables that are not cosθ or sinθ.

Parameters

e	The symbolic polynomial to be substituted.
sin_cos	sin_cos(i) is the pair of variables (sᵢ, cᵢ), (where sᵢ=sinθᵢ, cᵢ=cosθᵢ) as documented above.
t	New variables to express cos and sin as rationals of t. tᵢ = tan(θᵢ/2).

Precondition

t.rows() == sin_cos.size()

Returns

e_rational The rational polynomial of e after replacement. The indeterminates of the polynomials are t together with the indeterminates in e that are not cosθ or sinθ. Example

* std::vector<SinCos> sin_cos;
* sin_cos.emplace_back(symbolic::Variable("s0"), symbolic::Variable("c0"));
* sin_cos.emplace_back(symbolic::Variable("s1"), symbolic::Variable("c1"));
* Vector2<symbolic::Variable> t(symbolic::Variable("t0"),
*                               symbolic::Variable("t1"));
* const auto e_rational =
* SubstituteStereographicProjection(t(0) * sin_cos[0].s*sin_cos[1].c + 1,
*                                   sin_cos, t);
* // e_rational should be
* // (2*t0*t0*(1-t1*t1) + (1+t0*t0)*(1+t1*t1))
* // --------------------------------------------
* //        ((1+t0*t0)*(1+t1*t1))
* 

swap()

void swap	(	Expression &	a,
		Expression &	b )

tan()

Expression tan

(

const Expression &

e

)

tanh()

Expression tanh

(

const Expression &

e

)

TaylorExpand()

Expression TaylorExpand	(	const Expression &	f,
		const Environment &	a,
		int	order )

Returns the Taylor series expansion of f around a of order order.

Parameters

[in]	f	Symbolic expression to approximate using Taylor series expansion.
[in]	a	Symbolic environment which specifies the point of approximation. If a partial environment is provided, the unspecified variables are treated as symbolic variables (e.g. decision variable).
[in]	order	Positive integer which specifies the maximum order of the resulting polynomial approximating f around a.

to_conjunction()

std::shared_ptr< const FormulaAnd > to_conjunction

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaAnd>.

Precondition

is_conjunction(*f_ptr) is true.

to_disjunction()

std::shared_ptr< const FormulaOr > to_disjunction

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaOr>.

Precondition

is_disjunction(*f_ptr) is true.

to_equal_to()

std::shared_ptr< const FormulaEq > to_equal_to

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaEq>.

Precondition

is_equal_to(*f_ptr) is true.

to_false()

std::shared_ptr< const FormulaFalse > to_false

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaFalse>.

Precondition

is_false(*f_ptr) is true.

to_forall()

std::shared_ptr< const FormulaForall > to_forall

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaForall>.

Precondition

is_forall(*f_ptr) is true.

to_greater_than()

std::shared_ptr< const FormulaGt > to_greater_than

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaGt>.

Precondition

is_greater_than(*f_ptr) is true.

to_greater_than_or_equal_to()

std::shared_ptr< const FormulaGeq > to_greater_than_or_equal_to

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaGeq>.

Precondition

is_greater_than_or_equal_to(*f_ptr) is true.

to_isnan()

std::shared_ptr< const FormulaIsnan > to_isnan

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaIsnan>.

Precondition

is_isnan(*f_ptr) is true.

to_less_than()

std::shared_ptr< const FormulaLt > to_less_than

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaLt>.

Precondition

is_less_than(*f_ptr) is true.

to_less_than_or_equal_to()

std::shared_ptr< const FormulaLeq > to_less_than_or_equal_to

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaLeq>.

Precondition

is_less_than_or_equal_to(*f_ptr) is true.

to_nary()

std::shared_ptr< const NaryFormulaCell > to_nary

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const NaryFormulaCell>.

Precondition

is_nary(*f_ptr) is true.

to_negation()

std::shared_ptr< const FormulaNot > to_negation

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaNot>.

Precondition

is_negation(*f_ptr) is true.

to_not_equal_to()

std::shared_ptr< const FormulaNeq > to_not_equal_to

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaNeq>.

Precondition

is_not_equal_to(*f_ptr) is true.

to_positive_semidefinite()

std::shared_ptr< const FormulaPositiveSemidefinite > to_positive_semidefinite

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaPositiveSemidefinite>.

Precondition

is_positive_semidefinite(*f_ptr) is true.

to_relational()

std::shared_ptr< const RelationalFormulaCell > to_relational

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const RelationalFormulaCell>.

Precondition

is_relational(*f_ptr) is true.

to_true()

std::shared_ptr< const FormulaTrue > to_true

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaTrue>.

Precondition

is_true(*f_ptr) is true.

to_variable()

std::shared_ptr< const FormulaVar > to_variable

(

const std::shared_ptr< const FormulaCell > &

f_ptr

)

Casts f_ptr to shared_ptr<const FormulaVar>.

Precondition

is_variable(*f_ptr) is true.

ToLatex() [1/4]

template<typename Derived>

std::string ToLatex	(	const Eigen::PlainObjectBase< Derived > &	M,
		int	precision = 3 )

Generates a LaTeX string representation of M with floating point coefficients displayed using precision.

ToLatex() [2/4]

std::string ToLatex	(	const Expression &	e,
		int	precision = 3 )

Generates a LaTeX string representation of e with floating point coefficients displayed using precision.

ToLatex() [3/4]

std::string ToLatex	(	const Formula &	f,
		int	precision = 3 )

Generates a LaTeX string representation of f with floating point coefficients displayed using precision.

ToLatex() [4/4]

std::string ToLatex	(	double	val,
		int	precision = 3 )

Generates a Latex string representation of val displayed with precision, with one exception.

If the fractional part of val is exactly zero, then val is represented perfectly as an integer, and is displayed without the trailing decimal point and zeros (in this case, the precision argument is ignored).

uninterpreted_function()

Expression uninterpreted_function	(	std::string	name,
		std::vector< Expression >	arguments )

Constructs an uninterpreted-function expression with name and arguments.

An uninterpreted function is an opaque function that has no other property than its name and a list of its arguments. This is useful to applications where it is good enough to provide abstract information of a function without exposing full details. Declaring sparsity of a system is a typical example.

VisitExpression()

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.

Visitor object is expected to implement the following methods which take f and args: VisitConstant, VisitVariable, VisitAddition, VisitMultiplication, VisitDivision, VisitLog, VisitAbs, VisitExp, VisitSqrt, VisitPow, VisitSin, VisitCos, VisitTan, VisitAsin, VisitAtan, VisitAtan2, VisitSinh, VisitCosh, VisitTanh, VisitMin, VisitMax, VisitCeil, VisitFloor, VisitIfThenElse, VisitUninterpretedFunction.

Exceptions

std::exception

if NaN is detected during a visit.

VisitFormula()

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.

Visitor object is expected to implement the following methods which take f and args: VisitFalse, VisitTrue, VisitVariable, VisitEqualTo, VisitNotEqualTo, VisitGreaterThan, VisitGreaterThanOrEqualTo, VisitLessThan, VisitLessThanOrEqualTo, VisitConjunction, VisitDisjunction, VisitNegation, VisitForall, VisitIsnan, VisitPositiveSemidefinite.

Check the implementation of NegationNormalFormConverter class in drake/common/test/symbolic_formula_visitor_test.cc file to find an example.

VisitPolynomial()

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.

Visitor object is expected to implement the following methods which take f and args: VisitConstant, VisitVariable, VisitAddition, VisitMultiplication, VisitDivision, VisitPow.

Exceptions

std::exception

if NaN is detected during a visit.

See the implementation of DegreeVisitor class and Degree function in drake/common/symbolic_monomial.cc as an example usage.

Precondition

e.is_polynomial() is true.