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}} }@)@This is cppad-20221105 documentation. Here is a link to its current documentation .
AD Conditional Expressions

Syntax
result = CondExpRel(leftrightif_trueif_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 
Typeleft
It specifies the value for the left side of the comparison operator.

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

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

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

result
The result has prototype
    
Typeif_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(
flagif_trueif_false)
for the same meaning as
    CondExpGt(
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 .

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;
}

Input File: include/cppad/core/cond_exp.hpp