$\newcommand{\W}[1]{ \; #1 \; } \newcommand{\R}[1]{ {\rm #1} } \newcommand{\B}[1]{ {\bf #1} } \newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} } \newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} } \newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} } \newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }$

Syntax
result = CondExpRel(left, right, if_true, if_false)

Purpose
Record, as part of an AD of Base operation sequence , the conditional result       if( left Cop right )           result = if_true      else result = if_false  The relational Rel and comparison operator Cop above have the following correspondence:       Rel   Lt   Le   Eq   Ge   Gt      Cop    <   <=   ==   >=   >  If f is the ADFun object corresponding to the AD operation sequence, the assignment choice for result in an AD conditional expression is made each time f.Forward is used to evaluate the zero order Taylor coefficients with new values for the independent variables . This is in contrast to the AD comparison operators which are boolean valued and not included in the AD operation sequence.

Rel
In the syntax above, the relation Rel represents one of the following two characters: Lt, Le, Eq, Ge, Gt. As in the table above, Rel determines which comparison operator Cop is used when comparing left and right .

Type
These functions are defined in the CppAD namespace for arguments of Type is float , double, or any type of the form AD<Base> . (Note that all four arguments must have the same type.)

left
The argument left has prototype       const Type& left  It specifies the value for the left side of the comparison operator.

right
The argument right has prototype       const Type& right  It specifies the value for the right side of the comparison operator.

if_true
The argument if_true has prototype       const Type& if_true  It specifies the return value if the result of the comparison is true.

if_false
The argument if_false has prototype       const Type& if_false  It specifies the return value if the result of the comparison is false.

result
The result has prototype       Type& if_false 
Optimize
The optimize method will optimize conditional expressions in the following way: During zero order forward mode , once the value of the left and right have been determined, it is known if the true or false case is required. From this point on, values corresponding to the case that is not required are not computed. This optimization is done for the rest of zero order forward mode as well as forward and reverse derivatives calculations.

Deprecate 2005-08-07
Previous versions of CppAD used       CondExp(flag, if_true, if_false)  for the same meaning as       CondExpGt(flag, Type(0), if_true, if_false)  Use of CondExp is deprecated, but continues to be supported.

Operation Sequence
This is an AD of Base atomic operation and hence is part of the current AD of Base operation sequence .

Example

Test
The file cond_exp.cpp contains an example and test of this function. It returns true if it succeeds and false otherwise.

Atan2
The following implementation of the AD atan2 function is a more complex example of using conditional expressions:  template <class Base> AD<Base> atan2 (const AD<Base> &y, const AD<Base> &x) { AD<Base> alpha; AD<Base> beta; AD<Base> theta; AD<Base> zero(0.); AD<Base> pi2(2. * atan(1.)); AD<Base> pi(2. * pi2); AD<Base> ax = fabs(x); AD<Base> ay = fabs(y); // if( ax > ay ) // theta = atan(ay / ax); // else theta = pi2 - atan(ax / ay); alpha = atan(ay / ax); beta = pi2 - atan(ax / ay); theta = CondExpGt(ax, ay, alpha, beta); // use of CondExp // if( x <= 0 ) // theta = pi - theta; theta = CondExpLe(x, zero, pi - theta, theta); // use of CondExp // if( y <= 0 ) // theta = - theta; theta = CondExpLe(y, zero, -theta, theta); // use of CondExp return theta; }