Prev Next

@(@\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}} }@)@
AD Conditional Expressions

result = CondExpRel(leftrightif_trueif_false)

Record, as part of an AD of Base operation sequence , the conditional result
left Cop right )
result = if_true
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.

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 .

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

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

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

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

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

The result has prototype

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
for the same meaning as
flagType(0), if_trueif_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 .


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

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;

Input File: cppad/core/cond_exp.hpp