Drake
Expression Class Reference

Represents a symbolic form of an expression. More...

#include <drake/common/symbolic_expression.h>

Public Member Functions

 Expression ()
 Default constructor. More...
 
 Expression (double d)
 Constructs a constant. More...
 
 Expression (const Variable &var)
 Constructs an expression from var. More...
 
ExpressionKind get_kind () const
 Returns expression kind. More...
 
Variables GetVariables () const
 Collects variables in expression. More...
 
bool EqualTo (const Expression &e) const
 Checks structural equality. More...
 
bool Less (const Expression &e) const
 Provides lexicographical ordering between expressions. More...
 
bool is_polynomial () const
 Checks if this symbolic expression is convertible to Polynomial. More...
 
Polynomiald ToPolynomial () const
 Returns a Polynomial representing this expression. More...
 
double Evaluate (const Environment &env=Environment{}) const
 Evaluates under a given environment (by default, an empty environment). More...
 
Expression EvaluatePartial (const Environment &env) const
 Partially evaluates this expression using an environment env. More...
 
Expression Expand () const
 Expands out products and positive integer powers in expression. More...
 
Expression Substitute (const Variable &var, const Expression &e) const
 Returns a copy of this expression replacing all occurrences of var with e. More...
 
Expression Substitute (const Substitution &s) const
 Returns a copy of this expression replacing all occurrences of the variables in s with corresponding expressions in s. More...
 
Expression Differentiate (const Variable &x) const
 Differentiates this symbolic expression with respect to the variable var. More...
 
RowVectorX< ExpressionJacobian (const Eigen::Ref< const VectorX< Variable >> &vars) const
 Let f be this Expression, computes a row vector of derivatives, `[∂f/∂vars(0), ... More...
 
std::string to_string () const
 Returns string representation of Expression. More...
 
Expressionoperator++ ()
 Provides prefix increment operator (i.e. More...
 
Expression operator++ (int)
 Provides postfix increment operator (i.e. More...
 
Expressionoperator-- ()
 Provides prefix decrement operator (i.e. More...
 
Expression operator-- (int)
 Provides postfix decrement operator (i.e. More...
 
Implements CopyConstructible, CopyAssignable, MoveConstructible, MoveAssignable
 Expression (const Expression &)=default
 
Expressionoperator= (const Expression &)=default
 
 Expression (Expression &&)=default
 
Expressionoperator= (Expression &&)=default
 

Static Public Member Functions

static Expression Zero ()
 Returns zero. More...
 
static Expression One ()
 Returns one. More...
 
static Expression Pi ()
 Returns Pi, the ratio of a circle’s circumference to its diameter. More...
 
static Expression E ()
 Return e, the base of natural logarithms. More...
 
static Expression NaN ()
 Returns NaN (Not-a-Number). More...
 

Friends

class ExpressionAddFactory
 
class ExpressionMulFactory
 
template<class HashAlgorithm >
void hash_append (HashAlgorithm &hasher, const Expression &item) noexcept
 Implements the hash_append generic hashing concept. More...
 
Expression operator+ (Expression lhs, const Expression &rhs)
 
Expressionoperator+= (Expression &lhs, const Expression &rhs)
 
Expression operator+ (const Expression &e)
 Provides unary plus operator. More...
 
Expression operator- (Expression lhs, const Expression &rhs)
 
Expressionoperator-= (Expression &lhs, const Expression &rhs)
 
Expression operator- (const Expression &e)
 Provides unary minus operator. More...
 
Expression operator* (Expression lhs, const Expression &rhs)
 
Expressionoperator*= (Expression &lhs, const Expression &rhs)
 
Expression operator/ (Expression lhs, const Expression &rhs)
 
Expressionoperator/= (Expression &lhs, const Expression &rhs)
 
Expression log (const Expression &e)
 
Expression abs (const Expression &e)
 
Expression exp (const Expression &e)
 
Expression sqrt (const Expression &e)
 
Expression pow (const Expression &e1, const Expression &e2)
 
Expression sin (const Expression &e)
 
Expression cos (const Expression &e)
 
Expression tan (const Expression &e)
 
Expression asin (const Expression &e)
 
Expression acos (const Expression &e)
 
Expression atan (const Expression &e)
 
Expression atan2 (const Expression &e1, const Expression &e2)
 
Expression sinh (const Expression &e)
 
Expression cosh (const Expression &e)
 
Expression tanh (const Expression &e)
 
Expression min (const Expression &e1, const Expression &e2)
 
Expression max (const Expression &e1, const Expression &e2)
 
Expression ceil (const Expression &e)
 
Expression floor (const Expression &e)
 
Expression if_then_else (const Formula &f_cond, const Expression &e_then, const Expression &e_else)
 Constructs if-then-else expression. More...
 
Expression uninterpreted_function (std::string name, std::vector< Expression > arguments)
 Constructs an uninterpreted-function expression with name and arguments. More...
 
std::ostream & operator<< (std::ostream &os, const Expression &e)
 
void swap (Expression &a, Expression &b)
 
bool is_constant (const Expression &e)
 Checks if e is a constant expression. More...
 
bool is_variable (const Expression &e)
 Checks if e is a variable expression. More...
 
bool is_addition (const Expression &e)
 Checks if e is an addition expression. More...
 
bool is_multiplication (const Expression &e)
 Checks if e is a multiplication expression. More...
 
bool is_division (const Expression &e)
 Checks if e is a division expression. More...
 
bool is_log (const Expression &e)
 Checks if e is a log expression. More...
 
bool is_abs (const Expression &e)
 Checks if e is an abs expression. More...
 
bool is_exp (const Expression &e)
 Checks if e is an exp expression. More...
 
bool is_sqrt (const Expression &e)
 Checks if e is a square-root expression. More...
 
bool is_pow (const Expression &e)
 Checks if e is a power-function expression. More...
 
bool is_sin (const Expression &e)
 Checks if e is a sine expression. More...
 
bool is_cos (const Expression &e)
 Checks if e is a cosine expression. More...
 
bool is_tan (const Expression &e)
 Checks if e is a tangent expression. More...
 
bool is_asin (const Expression &e)
 Checks if e is an arcsine expression. More...
 
bool is_acos (const Expression &e)
 Checks if e is an arccosine expression. More...
 
bool is_atan (const Expression &e)
 Checks if e is an arctangent expression. More...
 
bool is_atan2 (const Expression &e)
 Checks if e is an arctangent2 expression. More...
 
bool is_sinh (const Expression &e)
 Checks if e is a hyperbolic-sine expression. More...
 
bool is_cosh (const Expression &e)
 Checks if e is a hyperbolic-cosine expression. More...
 
bool is_tanh (const Expression &e)
 Checks if e is a hyperbolic-tangent expression. More...
 
bool is_min (const Expression &e)
 Checks if e is a min expression. More...
 
bool is_max (const Expression &e)
 Checks if e is a max expression. More...
 
bool is_ceil (const Expression &e)
 Checks if e is a ceil expression. More...
 
bool is_floor (const Expression &e)
 Checks if e is a floor expression. More...
 
bool is_if_then_else (const Expression &e)
 Checks if e is an if-then-else expression. More...
 
bool is_uninterpreted_function (const Expression &e)
 Checks if e is an uninterpreted-function expression. More...
 
std::shared_ptr< const ExpressionConstantto_constant (const Expression &e)
 Casts e to shared_ptr<const ExpressionConstant>. More...
 
std::shared_ptr< const ExpressionVarto_variable (const Expression &e)
 Casts e to shared_ptr<const ExpressionVar>. More...
 
std::shared_ptr< const UnaryExpressionCellto_unary (const Expression &e)
 Casts e to shared_ptr<const UnaryExpressionCell>. More...
 
std::shared_ptr< const BinaryExpressionCellto_binary (const Expression &e)
 Casts e to shared_ptr<const BinaryExpressionCell>. More...
 
std::shared_ptr< const ExpressionAddto_addition (const Expression &e)
 Casts e to shared_ptr<const ExpressionAdd>. More...
 
std::shared_ptr< const ExpressionMulto_multiplication (const Expression &e)
 Casts e to shared_ptr<const ExpressionMul>. More...
 
std::shared_ptr< const ExpressionDivto_division (const Expression &e)
 Casts e to shared_ptr<const ExpressionDiv>. More...
 
std::shared_ptr< const ExpressionLogto_log (const Expression &e)
 Casts e to shared_ptr<const ExpressionLog>. More...
 
std::shared_ptr< const ExpressionAbsto_abs (const Expression &e)
 Casts e to shared_ptr<const ExpressionAbs>. More...
 
std::shared_ptr< const ExpressionExpto_exp (const Expression &e)
 Casts e to shared_ptr<const ExpressionExp>. More...
 
std::shared_ptr< const ExpressionSqrtto_sqrt (const Expression &e)
 Casts e to shared_ptr<const ExpressionSqrt>. More...
 
std::shared_ptr< const ExpressionPowto_pow (const Expression &e)
 Casts e to shared_ptr<const ExpressionPow>. More...
 
std::shared_ptr< const ExpressionSinto_sin (const Expression &e)
 Casts e to shared_ptr<const ExpressionSin>. More...
 
std::shared_ptr< const ExpressionCosto_cos (const Expression &e)
 Casts e to shared_ptr<const ExpressionCos>. More...
 
std::shared_ptr< const ExpressionTanto_tan (const Expression &e)
 Casts e to shared_ptr<const ExpressionTan>. More...
 
std::shared_ptr< const ExpressionAsinto_asin (const Expression &e)
 Casts e to shared_ptr<const ExpressionAsin>. More...
 
std::shared_ptr< const ExpressionAcosto_acos (const Expression &e)
 Casts e to shared_ptr<const ExpressionAcos>. More...
 
std::shared_ptr< const ExpressionAtanto_atan (const Expression &e)
 Casts e to shared_ptr<const ExpressionAtan>. More...
 
std::shared_ptr< const ExpressionAtan2to_atan2 (const Expression &e)
 Casts e to shared_ptr<const ExpressionAtan2>. More...
 
std::shared_ptr< const ExpressionSinhto_sinh (const Expression &e)
 Casts e to shared_ptr<const ExpressionSinh>. More...
 
std::shared_ptr< const ExpressionCoshto_cosh (const Expression &e)
 Casts e to shared_ptr<const ExpressionCosh>. More...
 
std::shared_ptr< const ExpressionTanhto_tanh (const Expression &e)
 Casts e to shared_ptr<const ExpressionTanh>. More...
 
std::shared_ptr< const ExpressionMinto_min (const Expression &e)
 Casts e to shared_ptr<const ExpressionMin>. More...
 
std::shared_ptr< const ExpressionMaxto_max (const Expression &e)
 Casts e to shared_ptr<const ExpressionMax>. More...
 
std::shared_ptr< const ExpressionCeilingto_ceil (const Expression &e)
 Casts e to shared_ptr<const ExpressionCeiling>. More...
 
std::shared_ptr< const ExpressionFloorto_floor (const Expression &e)
 Casts e to shared_ptr<const ExpressionFloor>. More...
 
std::shared_ptr< const ExpressionIfThenElseto_if_then_else (const Expression &e)
 Casts e to shared_ptr<const ExpressionIfThenElse>. More...
 
std::shared_ptr< const ExpressionUninterpretedFunctionto_uninterpreted_function (const Expression &e)
 Casts e to shared_ptr<const ExpressionUninterpretedFunction>. More...
 

Detailed Description

Represents a symbolic form of an expression.

Its syntax tree is as follows:

    E := Var | Constant | E + ... + E | E * ... * E | E / E | log(E)
       | abs(E) | exp(E) | sqrt(E) | pow(E, E) | sin(E) | cos(E) | tan(E)
       | asin(E) | acos(E) | atan(E) | atan2(E, E) | sinh(E) | cosh(E) | tanh(E)
       | min(E, E) | max(E, E) | ceil(E) | floor(E) | if_then_else(F, E, E)
       | NaN | uninterpreted_function(name, {v_1, ..., v_n})

In the implementation, Expression is a simple wrapper including a shared pointer to ExpressionCell class which is a super-class of different kinds of symbolic expressions (i.e. ExpressionAdd, ExpressionMul, ExpressionLog, ExpressionSin). Note that it includes a shared pointer, not a unique pointer, to allow sharing sub-expressions.

Note
The sharing of sub-expressions is not yet implemented.
-E is represented as -1 * E internally.
A subtraction E1 - E2 is represented as E1 + (-1 * E2) internally.

The following simple simplifications are implemented:

    E + 0             ->  E
    0 + E             ->  E
    E - 0             ->  E
    E - E             ->  0
    E * 1             ->  E
    1 * E             ->  E
    E * 0             ->  0
    0 * E             ->  0
    E / 1             ->  E
    E / E             ->  1
    pow(E, 0)         ->  1
    pow(E, 1)         ->  E
    E * E             ->  E^2 (= pow(E, 2))
    sqrt(E * E)       ->  |E| (= abs(E))
    sqrt(E) * sqrt(E) -> E

Constant folding is implemented:

    E(c1) + E(c2)  ->  E(c1 + c2)    // c1, c2 are constants
    E(c1) - E(c2)  ->  E(c1 - c2)
    E(c1) * E(c2)  ->  E(c1 * c2)
    E(c1) / E(c2)  ->  E(c1 / c2)
    f(E(c))        ->  E(f(c))       // c is a constant, f is a math function

For the math functions which are only defined over a restricted domain (namely, log, sqrt, pow, asin, acos), we check the domain of argument(s), and throw std::domain_error exception if a function is not well-defined for a given argument(s).

Relational operators over expressions (==, !=, <, >, <=, >=) return symbolic::Formula instead of bool. Those operations are declared in symbolic_formula.h file. To check structural equality between two expressions a separate function, Expression::EqualTo, is provided.

symbolic::Expression can be used as a scalar type of Eigen types.

Constructor & Destructor Documentation

◆ Expression() [1/5]

Expression ( const Expression )
default

◆ Expression() [2/5]

Expression ( Expression &&  )
default

◆ Expression() [3/5]

Expression ( )
inline

Default constructor.

It constructs Zero().

◆ Expression() [4/5]

Constructs a constant.

◆ Expression() [5/5]

Expression ( const Variable var)

Constructs an expression from var.

Precondition
var is neither a dummy nor a BOOLEAN variable.

Member Function Documentation

◆ Differentiate()

Expression Differentiate ( const Variable x) const

Differentiates this symbolic expression with respect to the variable var.

Exceptions
std::runtime_errorif it is not differentiable.

◆ E()

Expression E ( )
static

Return e, the base of natural logarithms.

◆ EqualTo()

bool EqualTo ( const Expression e) const

Checks structural equality.

Two expressions e1 and e2 are structurally equal when they have the same internal AST(abstract-syntax tree) representation. Please note that we can have two computationally (or extensionally) equivalent expressions which are not structurally equal. For example, consider:

e1 = 2 * (x + y) e2 = 2x + 2y

Obviously, we know that e1 and e2 are evaluated to the same value for all assignments to x and y. However, e1 and e2 are not structurally equal by the definition. Note that e1 is a multiplication expression (is_multiplication(e1) is true) while e2 is an addition expression (is_addition(e2) is true).

One main reason we use structural equality in EqualTo is due to Richardson's Theorem. It states that checking ∀x. E(x) = F(x) is undecidable when we allow sin, asin, log, exp in E and F. Read https://en.wikipedia.org/wiki/Richardson%27s_theorem for details.

Note that for polynomial cases, you can use Expand method and check if two polynomial expressions p1 and p2 are computationally equal. To do so, you check the following:

(p1.Expand() - p2.Expand()).EqualTo(0).

◆ Evaluate()

double Evaluate ( const Environment env = Environment{}) const

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

Exceptions
std::runtime_errorif NaN is detected during evaluation.

◆ EvaluatePartial()

Expression EvaluatePartial ( const Environment env) const

Partially evaluates this expression using an environment env.

Internally, this method promotes env into a substitution (VariableExpression) and call Evaluate::Substitute with it.

Exceptions
std::runtime_errorif NaN is detected during evaluation.

◆ Expand()

Expression Expand ( ) const

Expands out products and positive integer powers in expression.

For example, (x + 1) * (x - 1) is expanded to x^2 - 1 and (x + y)^2 is expanded to x^2 + 2xy + y^2. Note that Expand applies recursively to sub-expressions. For instance, sin(2 * (x + y)) is expanded to sin(2x + 2y). It also simplifies "division by constant" cases. See "drake/common/test/symbolic_expansion_test.cc" to find the examples.

Exceptions
std::runtime_errorif NaN is detected during expansion.

◆ get_kind()

ExpressionKind get_kind ( ) const

Returns expression kind.

◆ GetVariables()

Variables GetVariables ( ) const

Collects variables in expression.

◆ is_polynomial()

bool is_polynomial ( ) const

Checks if this symbolic expression is convertible to Polynomial.

◆ Jacobian()

RowVectorX< Expression > Jacobian ( const Eigen::Ref< const VectorX< Variable >> &  vars) const

Let f be this Expression, computes a row vector of derivatives, `[∂f/∂vars(0), ...

, ∂f/∂vars(n-1)]` with respect to the variables vars.

◆ Less()

bool Less ( const Expression e) const

Provides lexicographical ordering between expressions.

This function is used as a compare function in map<Expression> and set<Expression> via std::less<drake::symbolic::Expression>.

◆ NaN()

Expression NaN ( )
static

Returns NaN (Not-a-Number).

◆ One()

Expression One ( )
static

Returns one.

◆ operator++() [1/2]

Expression & operator++ ( )

Provides prefix increment operator (i.e.

++x).

◆ operator++() [2/2]

Expression operator++ ( int  )

Provides postfix increment operator (i.e.

x++).

◆ operator--() [1/2]

Expression & operator-- ( )

Provides prefix decrement operator (i.e.

–x).

◆ operator--() [2/2]

Expression operator-- ( int  )

Provides postfix decrement operator (i.e.

x–).

◆ operator=() [1/2]

Expression& operator= ( const Expression )
default

◆ operator=() [2/2]

Expression& operator= ( Expression &&  )
default

◆ Pi()

Expression Pi ( )
static

Returns Pi, the ratio of a circle’s circumference to its diameter.

◆ Substitute() [1/2]

Expression Substitute ( const Variable var,
const Expression e 
) const

Returns a copy of this expression replacing all occurrences of var with e.

Exceptions
std::runtime_errorif NaN is detected during substitution.

◆ Substitute() [2/2]

Expression Substitute ( const Substitution s) const

Returns a copy of this expression replacing all occurrences of the variables in s with corresponding expressions in s.

Note that the substitutions occur simultaneously. For example, (x / y).Substitute({{x, y}, {y, x}}) gets (y / x).

Exceptions
std::runtime_errorif NaN is detected during substitution.

◆ to_string()

string to_string ( ) const

Returns string representation of Expression.

◆ ToPolynomial()

Polynomiald ToPolynomial ( ) const

Returns a Polynomial representing this expression.

Note that the ID of a variable is preserved in this translation.

Precondition
{is_polynomial() is true.}

◆ Zero()

Expression Zero ( )
static

Returns zero.

Friends And Related Function Documentation

◆ abs

Expression abs ( const Expression e)
friend

◆ acos

Expression acos ( const Expression e)
friend

◆ asin

Expression asin ( const Expression e)
friend

◆ atan

Expression atan ( const Expression e)
friend

◆ atan2

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

◆ ceil

Expression ceil ( const Expression e)
friend

◆ cos

Expression cos ( const Expression e)
friend

◆ cosh

Expression cosh ( const Expression e)
friend

◆ exp

Expression exp ( const Expression e)
friend

◆ ExpressionAddFactory

friend class ExpressionAddFactory
friend

◆ ExpressionMulFactory

friend class ExpressionMulFactory
friend

◆ floor

Expression floor ( const Expression e)
friend

◆ hash_append

void hash_append ( HashAlgorithm &  hasher,
const Expression item 
)
friend

Implements the hash_append generic hashing concept.

◆ if_then_else

Expression if_then_else ( const Formula f_cond,
const Expression e_then,
const Expression e_else 
)
friend

Constructs if-then-else expression.

  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.

◆ is_abs

bool is_abs ( const Expression e)
friend

Checks if e is an abs expression.

◆ is_acos

bool is_acos ( const Expression e)
friend

Checks if e is an arccosine expression.

◆ is_addition

bool is_addition ( const Expression e)
friend

Checks if e is an addition expression.

◆ is_asin

bool is_asin ( const Expression e)
friend

Checks if e is an arcsine expression.

◆ is_atan

bool is_atan ( const Expression e)
friend

Checks if e is an arctangent expression.

◆ is_atan2

bool is_atan2 ( const Expression e)
friend

Checks if e is an arctangent2 expression.

◆ is_ceil

bool is_ceil ( const Expression e)
friend

Checks if e is a ceil expression.

◆ is_constant

bool is_constant ( const Expression e)
friend

Checks if e is a constant expression.

◆ is_cos

bool is_cos ( const Expression e)
friend

Checks if e is a cosine expression.

◆ is_cosh

bool is_cosh ( const Expression e)
friend

Checks if e is a hyperbolic-cosine expression.

◆ is_division

bool is_division ( const Expression e)
friend

Checks if e is a division expression.

◆ is_exp

bool is_exp ( const Expression e)
friend

Checks if e is an exp expression.

◆ is_floor

bool is_floor ( const Expression e)
friend

Checks if e is a floor expression.

◆ is_if_then_else

bool is_if_then_else ( const Expression e)
friend

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

◆ is_log

bool is_log ( const Expression e)
friend

Checks if e is a log expression.

◆ is_max

bool is_max ( const Expression e)
friend

Checks if e is a max expression.

◆ is_min

bool is_min ( const Expression e)
friend

Checks if e is a min expression.

◆ is_multiplication

bool is_multiplication ( const Expression e)
friend

Checks if e is a multiplication expression.

◆ is_pow

bool is_pow ( const Expression e)
friend

Checks if e is a power-function expression.

◆ is_sin

bool is_sin ( const Expression e)
friend

Checks if e is a sine expression.

◆ is_sinh

bool is_sinh ( const Expression e)
friend

Checks if e is a hyperbolic-sine expression.

◆ is_sqrt

bool is_sqrt ( const Expression e)
friend

Checks if e is a square-root expression.

◆ is_tan

bool is_tan ( const Expression e)
friend

Checks if e is a tangent expression.

◆ is_tanh

bool is_tanh ( const Expression e)
friend

Checks if e is a hyperbolic-tangent expression.

◆ is_uninterpreted_function

bool is_uninterpreted_function ( const Expression e)
friend

Checks if e is an uninterpreted-function expression.

◆ is_variable

bool is_variable ( const Expression e)
friend

Checks if e is a variable expression.

◆ log

Expression log ( const Expression e)
friend

◆ max

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

◆ min

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

◆ operator*

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

◆ operator*=

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

◆ operator+ [1/2]

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

◆ operator+ [2/2]

Expression operator+ ( const Expression e)
friend

Provides unary plus operator.

◆ operator+=

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

◆ operator- [1/2]

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

◆ operator- [2/2]

Expression operator- ( const Expression e)
friend

Provides unary minus operator.

◆ operator-=

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

◆ operator/

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

◆ operator/=

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

◆ operator<<

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

◆ pow

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

◆ sin

Expression sin ( const Expression e)
friend

◆ sinh

Expression sinh ( const Expression e)
friend

◆ sqrt

Expression sqrt ( const Expression e)
friend

◆ swap

void swap ( Expression a,
Expression b 
)
friend

◆ tan

Expression tan ( const Expression e)
friend

◆ tanh

Expression tanh ( const Expression e)
friend

◆ to_abs

std::shared_ptr<const ExpressionAbs> to_abs ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionAbs>.

Precondition
*(e.ptr_) is of ExpressionAbs.

◆ to_acos

std::shared_ptr<const ExpressionAcos> to_acos ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionAcos>.

Precondition
*(e.ptr_) is of ExpressionAcos.

◆ to_addition

std::shared_ptr<const ExpressionAdd> to_addition ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionAdd>.

Precondition
*(e.ptr_) is of ExpressionAdd.

◆ to_asin

std::shared_ptr<const ExpressionAsin> to_asin ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionAsin>.

Precondition
*(e.ptr_) is of ExpressionAsin.

◆ to_atan

std::shared_ptr<const ExpressionAtan> to_atan ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionAtan>.

Precondition
*(e.ptr_) is of ExpressionAtan.

◆ to_atan2

std::shared_ptr<const ExpressionAtan2> to_atan2 ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionAtan2>.

Precondition
*(e.ptr_) is of ExpressionAtan2.

◆ to_binary

std::shared_ptr<const BinaryExpressionCell> to_binary ( const Expression e)
friend

Casts e to shared_ptr<const BinaryExpressionCell>.

Precondition
*(e.ptr_) is of BinaryExpressionCell.

◆ to_ceil

std::shared_ptr<const ExpressionCeiling> to_ceil ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionCeiling>.

Precondition
*(e.ptr_) is of ExpressionCeiling.

◆ to_constant

std::shared_ptr<const ExpressionConstant> to_constant ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionConstant>.

Precondition
*(e.ptr_) is of ExpressionConstant.

◆ to_cos

std::shared_ptr<const ExpressionCos> to_cos ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionCos>.

Precondition
*(e.ptr_) is of ExpressionCos.

◆ to_cosh

std::shared_ptr<const ExpressionCosh> to_cosh ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionCosh>.

Precondition
*(e.ptr_) is of ExpressionCosh.

◆ to_division

std::shared_ptr<const ExpressionDiv> to_division ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionDiv>.

Precondition
*(e.ptr_) is of ExpressionDiv.

◆ to_exp

std::shared_ptr<const ExpressionExp> to_exp ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionExp>.

Precondition
*(e.ptr_) is of ExpressionExp.

◆ to_floor

std::shared_ptr<const ExpressionFloor> to_floor ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionFloor>.

Precondition
*(e.ptr_) is of ExpressionFloor.

◆ to_if_then_else

std::shared_ptr<const ExpressionIfThenElse> to_if_then_else ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionIfThenElse>.

Precondition
*(e.ptr_) is of ExpressionIfThenElse.

◆ to_log

std::shared_ptr<const ExpressionLog> to_log ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionLog>.

Precondition
*(e.ptr_) is of ExpressionLog.

◆ to_max

std::shared_ptr<const ExpressionMax> to_max ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionMax>.

Precondition
*(e.ptr_) is of ExpressionMax.

◆ to_min

std::shared_ptr<const ExpressionMin> to_min ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionMin>.

Precondition
*(e.ptr_) is of ExpressionMin.

◆ to_multiplication

std::shared_ptr<const ExpressionMul> to_multiplication ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionMul>.

Precondition
*(e.ptr_) is of ExpressionMul.

◆ to_pow

std::shared_ptr<const ExpressionPow> to_pow ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionPow>.

Precondition
*(e.ptr_) is of ExpressionPow.

◆ to_sin

std::shared_ptr<const ExpressionSin> to_sin ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionSin>.

Precondition
*(e.ptr_) is of ExpressionSin.

◆ to_sinh

std::shared_ptr<const ExpressionSinh> to_sinh ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionSinh>.

Precondition
*(e.ptr_) is of ExpressionSinh.

◆ to_sqrt

std::shared_ptr<const ExpressionSqrt> to_sqrt ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionSqrt>.

Precondition
*(e.ptr_) is of ExpressionSqrt.

◆ to_tan

std::shared_ptr<const ExpressionTan> to_tan ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionTan>.

Precondition
*(e.ptr_) is of ExpressionTan.

◆ to_tanh

std::shared_ptr<const ExpressionTanh> to_tanh ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionTanh>.

Precondition
*(e.ptr_) is of ExpressionTanh.

◆ to_unary

std::shared_ptr<const UnaryExpressionCell> to_unary ( const Expression e)
friend

Casts e to shared_ptr<const UnaryExpressionCell>.

Precondition
*(e.ptr_) is of UnaryExpressionCell.

◆ to_uninterpreted_function

std::shared_ptr<const ExpressionUninterpretedFunction> to_uninterpreted_function ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionUninterpretedFunction>.

Precondition
*(e.ptr_) is of ExpressionUninterpretedFunction.

◆ to_variable

std::shared_ptr<const ExpressionVar> to_variable ( const Expression e)
friend

Casts e to shared_ptr<const ExpressionVar>.

Precondition
*(e.ptr_) is of ExpressionVar.

◆ uninterpreted_function

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

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.


The documentation for this class was generated from the following files: