CondExp¶

AD Conditional Expressions¶

Syntax¶

result = CondExp Rel ( 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 Base or AD < Base > . Note that all four arguments, left , right, if_true , if_false , 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.

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)
{  //
   // zero, pi2, pi
   AD<Base> zero(0.);
   AD<Base> pi2(2. * atan(1.));
   AD<Base> pi(2. * pi2);
   //
   // abs_x, abs_y
   // Not using fabs because its derivative is zero at zero
   AD<Base> abs_x = CondExpGe(x, zero, x, -x);
   AD<Base> abs_y = CondExpGe(y, zero, y, -y);
   //
   // first
   // This is the result for first quadrant: x >= 0 , y >= 0
   AD<Base> alpha = atan(abs_y / abs_x);
   AD<Base> beta  = pi2 - atan(abs_x / abs_y);
   AD<Base> first = CondExpGt(abs_x, abs_y, alpha, beta);
   //
   // second
   // This is the result for second quadrant: x <= 0 , y >= 0
   AD<Base> second = pi - first;
   //
   // third
   // This is the result for third quadrant: x <= 0 , y <= 0
   AD<Base> third = - pi + first;
   //
   // fourth
   // This is the result for fourth quadrant: x >= 0 , y <= 0
   AD<Base> fourth = - first;
   //
   // alpha
   // This is the result for x >= 0
   alpha = CondExpGe(y, zero, first, fourth);
   //
   // beta
   // This is the result for x <= 0
   beta = CondExpGe(y, zero, second, third);
   //
   //
   AD<Base> result = CondExpGe(x, zero, alpha, beta);
   return result;
}