\(\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}} }\)

atomic_four_vector_for_type.hpp

View page source

Atomic Vector Forward Type Calculation: Example Implementation

Purpose

The for_type routine overrides the virtual functions used by the atomic_four base; see for_type .

Source

# include <cppad/example/atomic_four/vector/vector.hpp>

namespace CppAD { // BEGIN_CPPAD_NAMESPACE
//
// for_type override
template <class Base>
bool atomic_vector<Base>::for_type(
    size_t                                     call_id     ,
    const CppAD::vector<CppAD::ad_type_enum>&  type_x      ,
    CppAD::vector<CppAD::ad_type_enum>&        type_y      )
{
    // n, m, op
    size_t n     = type_x.size();
    size_t m     = type_y.size();
    op_enum_t op = op_enum_t( call_id );
    //
    // type_y
    if( n == m )
    {   // unary operator
        for(size_t i = 0; i < m; ++i)
            type_y[i] = type_x[i];
    }
    else
    {   // binary operator
        for(size_t i = 0; i < m; ++i)
            type_y[i] = std::max( type_x[i] , type_x[m + i] );
    }
    switch(op)
    {
        // addition, subtraction
        // not sure result is identically 0 unless both are identically 0
        case add_enum:
        case sub_enum:
        for(size_t i = 0; i < m; ++i)
            type_y[i] = std::max( type_x[i] , type_x[m + i] );
        break;


        // multiplication
        // treat multiplication by zero like absolute zero
        case mul_enum:
        for(size_t i = 0; i < m; ++i)
        {   if( type_x[i] == identical_zero_enum )
                type_y[i] = identical_zero_enum;
            else if( type_x[m + i] == identical_zero_enum )
                type_y[i] = identical_zero_enum;
            else
                type_y[i] = std::max( type_x[i] , type_x[m + i] );
        }
        break;

        // division
        // treat divition of zero like absolute zero
        case div_enum:
        for(size_t i = 0; i < m; ++i)
        {   if( type_x[i] == identical_zero_enum )
                type_y[i] = identical_zero_enum;
            else
                type_y[i] = std::max( type_x[i] , type_x[m + i] );
        }
        break;

        // unary minus
        case neg_enum:
        for(size_t i = 0; i < m; ++i)
            type_y[i] = type_x[i];
        break;

        // error
        case number_op_enum:
        assert(false);
        break;
    }
    return true;
}
} // END_CPPAD_NAMESPACE