AD Conditional Expressions
Keywords: ad conditional expressions assign syntax purpose rel type left right if_true if_false result optimize deprecate 2005-08-07 operation sequence example test atan2

| Prev | Next |  |  |  |  |  |  |

AD Conditional Expressions
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. There is one exception to this optimization; see optimizing nested conditional expressions .
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 = abs(x);
    	AD<Base> ay = abs(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/local/cond_exp.hpp