Changeset 1447


Ignore:
Timestamp:
Jul 4, 2009 3:15:09 PM (11 years ago)
Author:
bradbell
Message:

trunk: Merge in branches/sweep from revision 1404 to 1446.

Location:
trunk
Files:
2 deleted
64 edited
8 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/AUTHORS

    r1401 r1447  
    22             ===========================================
    33
    4 To date, 2009-06-24, Bradley M. Bell is the sole author of CppAD.
     4To date, 2009-07-04, Bradley M. Bell is the sole author of CppAD.
    55While Bradley M. Bell worked for the University of Washington during
    66the development of CppAD, the following are also true:
  • trunk/build.sh

    r1401 r1447  
    1313#
    1414# Bash script for building the CppAD distribution.
     15#
     16# check for multiple options case
     17if [ "$1" != "" ] && [ "$1" != all ] && [ "$2" != "" ]
     18then
     19        list=" version automake config_none config_test"
     20        list="$list omhelp doxygen make dist test gpl dos move "
     21        for option in $*
     22        do
     23                if [ "$option" == "all" ]
     24                then
     25                        echo "Error in build.sh command."
     26                        echo "If present, \"all\" must be first option" 
     27                        exit 1
     28                fi
     29                if ! echo "$list" | grep " $option " > /dev/null
     30                then
     31                        # run invalid option for error message
     32                        ./build.sh $option
     33                        exit 1
     34                fi
     35        done
     36        for option in $*
     37        do
     38                echo "========================================================"
     39                echo "./build.sh $option"
     40                if ! ./build.sh $option
     41                then
     42                        exit 1
     43                fi
     44        done
     45fi
     46if [ "$1" = "all" ] && [ "$2" != "" ] && [ "$2" != "test" ] && [ "$2" != "dos" ]
     47then
     48        echo "./build.sh $1 $2"
     49        echo "is not a valid valid choice."
     50        ./build.sh
     51        exit 1
     52fi
    1553#
    1654# Default values used for arguments to configure during this script.
     
    2967        sed -e 's/[^,]*, *\([^ ,]*\).*/\1/'`
    3068#
    31 if [ "$1" = "all" ] && [ "$2" != "" ] && [ "$2" != "test" ] && [ "$2" != "dos" ]
    32 then
    33         echo "./build.sh $1 $2"
    34         echo "is not valid, build.sh with no arguments lists valid choices."
    35         exit 1
    36 fi
    3769#
    3870# Check if we are running all the test cases.
     
    180212# configure
    181213#
    182 if [ "$1" = "configure" ] || [ "$1" = "all" ]
    183 then
    184         if [ "$2" = "test" ]
    185         then
    186                 echo "build.sh configure test"
    187         else
    188                 echo "build.sh configure"
    189         fi
    190         #
    191         TEST=""
    192         if [ "$1" = "configure" ] && [ "$2" = "test" ]
    193         then
    194                 TEST="
    195                         --with-Introduction
    196                         --with-Example
    197                         --with-TestMore
    198                         --with-Speed
    199                         --with-PrintFor"
    200                 if [ -e doc/index.htm ]
    201                 then
    202                         TEST="$TEST
    203                                 --with-Documentation"
    204                 fi
     214TEST=""
     215if [ "$1" = "config_test" ]
     216then
     217        TEST="
     218                --with-Introduction
     219                --with-Example
     220                --with-TestMore
     221                --with-Speed
     222                --with-PrintFor"
     223        if [ -e doc/index.htm ]
     224        then
    205225                TEST="$TEST
    206                         POSTFIX_DIR=coin"
    207                 if [ -e $BOOST_DIR/boost ]
    208                 then
    209                         TEST="$TEST
    210                                 BOOST_DIR=$BOOST_DIR"
    211                 fi
    212                 if [ -e $ADOLC_DIR/include/adolc ]
    213                 then
    214                         TEST="$TEST
    215                                 ADOLC_DIR=$ADOLC_DIR"
    216                 fi
    217                 if [ -e $FADBAD_DIR/FADBAD++ ]
    218                 then
    219                         TEST="$TEST
    220                                 FADBAD_DIR=$FADBAD_DIR"
    221                 fi
    222                 if [ -e $SACADO_DIR/include/Sacado.hpp ]
    223                 then
    224                         TEST="$TEST
    225                                 SACADO_DIR=$SACADO_DIR"
    226                 fi
    227                 if [ -e $IPOPT_DIR/include/coin/IpIpoptApplication.hpp ]
    228                 then
    229                         TEST="$TEST
    230                                 IPOPT_DIR=$IPOPT_DIR"
    231                 fi
     226                        --with-Documentation"
     227        fi
     228        TEST="$TEST
     229                POSTFIX_DIR=coin"
     230        if [ -e $BOOST_DIR/boost ]
     231        then
     232                TEST="$TEST
     233                        BOOST_DIR=$BOOST_DIR"
     234        fi
     235        if [ -e $ADOLC_DIR/include/adolc ]
     236        then
     237                TEST="$TEST
     238                        ADOLC_DIR=$ADOLC_DIR"
     239        fi
     240        if [ -e $FADBAD_DIR/FADBAD++ ]
     241        then
     242                TEST="$TEST
     243                        FADBAD_DIR=$FADBAD_DIR"
     244        fi
     245        if [ -e $SACADO_DIR/include/Sacado.hpp ]
     246        then
     247                TEST="$TEST
     248                        SACADO_DIR=$SACADO_DIR"
     249        fi
     250        if [ -e $IPOPT_DIR/include/coin/IpIpoptApplication.hpp ]
     251        then
     252                TEST="$TEST
     253                        IPOPT_DIR=$IPOPT_DIR"
    232254        fi
    233255        TEST=`echo $TEST | sed -e 's|\t\t*| |g'`
    234         #
     256fi
     257if [ "$1" = "config_test" ] || [ "$1" = "config_none" ] || [ "$1" = "all" ]
     258then
    235259        echo "configure \\"
    236260        echo "$TEST" | sed -e 's| | \\\n\t|g' -e 's|$| \\|' -e 's|^|\t|'
     
    246270        echo "fix_makefile.sh"
    247271        ./fix_makefile.sh
    248         #
    249         if [ "$1" = "configure" ]
    250         then
    251                 exit 0
    252         fi
    253272        #
    254273        # make shell scripts created by configure executable
     
    257276        echo "chmod +x test_more/test_one.sh"
    258277        chmod +x test_more/test_one.sh
     278        #
     279        if [ "$1" = "config_test" ] || [ "$1" = "config_none" ]
     280        then
     281                exit 0
     282        fi
    259283fi
    260284#
     
    498522        # Configure
    499523        #
    500         if ! ./build.sh configure test
    501         then
    502                 echo "Error: build.sh configure test"  >> $dir/build_test.log
    503                 echo "Error: build.sh configure test"
     524        if ! ./build.sh config_test
     525        then
     526                echo "Error: build.sh config_test"  >> $dir/build_test.log
     527                echo "Error: build.sh config_test"
    504528                exit 1
    505529        fi
     
    522546                                echo "$msg" >> $dir/build_test.log
    523547                                echo "$msg"
     548                                mv omhelp.$user.$ext.log $dir
    524549                                exit 1
    525550                        fi
     
    706731if [ "$1" = "move" ] || [ "$1" = "all" ]
    707732then
    708         # copy tarballs into doc directory
     733        # move tarballs into doc directory
    709734        list="
    710735                cppad-$version.cpl.tgz
     
    756781echo "version        update configure.ac and doc.omh version number"
    757782echo "automake       run aclocal,autoheader,autoconf,automake -> configure"
    758 echo "configure      excludes --with-*"
    759 echo "configure test includes all the possible options except PREFIX_DIR"
     783echo "config_none    excludes all possible testing options"
     784echo "config_test    includes all the possible testing options"
    760785echo "omhelp         build all formats for user documentation in doc/*"
    761786echo "doxygen        build developer documentation in doxydoc/*"
     
    767792echo "move           move *.tgz to doc directory"
    768793echo
     794echo "build.sh option_1 option_2 ..."
     795echo "Where options are in list above, executes them in the specified order."
     796echo
    769797echo "build.sh all"
    770 echo "This command will execute all the options above in order with the"
    771 echo "exception that \"configue test\", \"test\", and \"dos\" are excluded."
     798echo "Execute all options except config_test, test, and dos are excluded."
    772799echo
    773800echo "build.sh all dos"
    774 echo "This command will execute all the options above in order with the"
    775 echo "exception that \"configure test\" and \"test\" are excluded."
     801echo "Execute all options except config_test, and test are excluded."
    776802echo
    777803echo "build.sh all test"
    778 echo "This command will execute all the options above in order with the"
    779 echo "exception that \"configure\",  \"dos\", and \"move\" are excluded."
     804echo "Execute all options except config_none, and dos, are excluded."
    780805#
    781806exit 1
  • trunk/check_doxygen.sh

    r1401 r1447  
    1414list="
    1515        abs_op.hpp
     16        add_op.hpp
     17        acos_op.hpp
     18        asin_op.hpp
     19        cond_op.hpp
    1620        configure.hpp
     21        cos_op.hpp
     22        cosh_op.hpp
     23        cppad_assert.hpp
    1724        define.hpp
     25        div_op.hpp
     26        log_op.hpp
     27        mul_op.hpp
    1828        op_code.hpp
    1929        player.hpp
    20         unary_op.hpp
     30        pow_op.hpp
     31        prototype_op.hpp
     32        sin_op.hpp
     33        sinh_op.hpp
     34        sparse_op.hpp
     35        sqrt_op.hpp
     36        sub_op.hpp
    2137"
    2238for name in $list
  • trunk/check_include_file.sh

    r1401 r1447  
    3030#
    3131cat junk.1 | sed -e 's%[^<]*<%%'  -e 's%>.*$%%' | sort -u > junk.2
    32 # The file cppad/local/unary_op should never be included.
     32# The file cppad/local/prototype_op should never be included.
    3333# All other files should.
    3434ls      cppad/config.h \
     
    3636        cppad/local/*.hpp \
    3737        cppad/speed/*.hpp \
    38         | sed -e '/cppad\/local\/unary_op.hpp/d' | sort > junk.3
     38        | sed -e '/cppad\/local\/prototype_op.hpp/d' | sort > junk.3
    3939if diff junk.2 junk.3
    4040then
  • trunk/configure

    r1401 r1447  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.63 for CppAD 20090624.
     3# Generated by GNU Autoconf 2.63 for CppAD 20090704
    44#
    55# Report bugs to <cppad@list.coin-or.org>.
     
    597597PACKAGE_NAME='CppAD'
    598598PACKAGE_TARNAME='cppad'
    599 PACKAGE_VERSION='20090624'
    600 PACKAGE_STRING='CppAD 20090624'
     599PACKAGE_VERSION='20090704'
     600PACKAGE_STRING='CppAD 20090704'
    601601PACKAGE_BUGREPORT='cppad@list.coin-or.org'
    602602
     
    13211321  # This message is too long to be a string in the A/UX 3.1 sh.
    13221322  cat <<_ACEOF
    1323 \`configure' configures CppAD 20090624 to adapt to many kinds of systems.
     1323\`configure' configures CppAD 20090704 to adapt to many kinds of systems.
    13241324
    13251325Usage: $0 [OPTION]... [VAR=VALUE]...
     
    13871387if test -n "$ac_init_help"; then
    13881388  case $ac_init_help in
    1389      short | recursive ) echo "Configuration of CppAD 20090624:";;
     1389     short | recursive ) echo "Configuration of CppAD 20090704:";;
    13901390   esac
    13911391  cat <<\_ACEOF
     
    15001500if $ac_init_version; then
    15011501  cat <<\_ACEOF
    1502 CppAD configure 20090624
     1502CppAD configure 20090704
    15031503generated by GNU Autoconf 2.63
    15041504
     
    15141514running configure, to aid debugging if configure makes a mistake.
    15151515
    1516 It was created by CppAD $as_me 20090624, which was
     1516It was created by CppAD $as_me 20090704, which was
    15171517generated by GNU Autoconf 2.63.  Invocation command line was
    15181518
     
    38523852# Define the identity of the package.
    38533853 PACKAGE='cppad'
    3854  VERSION='20090624'
     3854 VERSION='20090704'
    38553855
    38563856
     
    62426242# values after options handling.
    62436243ac_log="
    6244 This file was extended by CppAD $as_me 20090624, which was
     6244This file was extended by CppAD $as_me 20090704, which was
    62456245generated by GNU Autoconf 2.63.  Invocation command line was
    62466246
     
    63056305cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
    63066306ac_cs_version="\\
    6307 CppAD config.status 20090624
     6307CppAD config.status 20090704
    63086308configured by $0, generated by GNU Autoconf 2.63,
    63096309  with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
  • trunk/configure.ac

    r1401 r1447  
    1313dnl Process this file with autoconf to produce a configure script.
    1414dnl   package   version              bug-report
    15 AC_INIT(CppAD, 20090624, cppad@list.coin-or.org)
     15AC_INIT(CppAD, 20090704, cppad@list.coin-or.org)
    1616
    1717dnl By defalut disable maintainer mode when running configure;
  • trunk/cppad/config.h

    r1401 r1447  
    2424
    2525/* Define to the full name and version of this package. */
    26 #define PACKAGE_STRING "CppAD 20090624"
     26#define PACKAGE_STRING "CppAD 20090704"
    2727
    2828/* Define to the one symbol short name of this package. */
     
    3030
    3131/* Define to the version of this package. */
    32 #define PACKAGE_VERSION "20090624"
     32#define PACKAGE_VERSION "20090704"
    3333
    3434/* Version number of package */
    35 #define VERSION "20090624"
     35#define VERSION "20090704"
    3636
    3737/* Define to `__inline__' or `__inline' if that's what the C compiler
  • trunk/cppad/configure.hpp

    r1401 r1447  
    1 /* $Id: configure.hpp.in 1393 2009-06-21 05:56:40Z bradbell $ */
     1/* $Id: configure.hpp.in 1401 2009-06-24 17:56:51Z bradbell $ */
    22/* This file may be inclued multiple times so comment out ifndef and define
    33# ifndef CPPAD_CONFIGURE_INCLUDED
     
    6161cppad-yyyymmdd as a C string where yyyy is year, mm is month, and dd is day.
    6262*/
    63 # define CPPAD_PACKAGE_STRING "CppAD 20090624"
     63# define CPPAD_PACKAGE_STRING "CppAD 20090704"
    6464
    6565/*
  • trunk/cppad/cppad.hpp

    r1401 r1447  
    7474// ---------------------------------------------------------------------------
    7575
     76# include <cppad/local/user_ad.hpp>  // AD class methods available to the user
     77// tape that tape for AD<Base> acts as a user of Base operations
     78// so user_ad.hpp must come before op.hpp
    7679# include <cppad/local/op.hpp>       // executes taped operations
    77 # include <cppad/local/user_ad.hpp>  // AD class methods available to the user
    7880# include <cppad/local/ad_fun.hpp>   // ADFun objects
    7981
  • trunk/cppad/local/abs.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    141141        if( Variable(*this) )
    142142        {       // add this operation to the tape
    143                 CPPAD_ASSERT_UNKNOWN( NumVar(AbsOp) == 1 );
    144                 CPPAD_ASSERT_UNKNOWN( NumInd(AbsOp) == 1 );
     143                CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
     144                CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
    145145                ADTape<Base> *tape = tape_this();
    146146
    147147                // corresponding operand address
    148                 tape->Rec_.PutInd(taddr_);
     148                tape->Rec_.PutArg(taddr_);
    149149                // put operator in the tape
    150150                result.taddr_ = tape->Rec_.PutOp(AbsOp);
  • trunk/cppad/local/abs_op.hpp

    r1401 r1447  
    1818/*!
    1919\file abs_op.hpp
     20Forward and reverse mode calculations for z = abs(x).
    2021*/
    2122
    2223
    2324/*!
    24 Forward mode Taylor coefficient for result of op = AbsOp.
     25Compute forward mode Taylor coefficient for result of op = AbsOp.
    2526
    2627The C++ source code corresponding to this operation is
    2728\verbatim
    28         z = abs(y)
     29        z = abs(x)
    2930\endverbatim
    3031
    31 \copydetails forward_unary_op
     32\copydetails forward_unary1_op
    3233*/
    3334template <class Base>
    3435inline void forward_abs_op(
    35         size_t p           ,
     36        size_t j           ,
    3637        size_t i_z         ,
    37         const size_t *arg  ,
     38        size_t i_x         ,
    3839        size_t nc_taylor   ,
    39         Base   *taylor     )
     40        Base*  taylor      )
    4041{
     42        size_t k;
    4143        static Base zero(0);
    4244
    4345        // check assumptions
    44         CPPAD_ASSERT_UNKNOWN( NumInd(AbsOp) == 1 );
    45         CPPAD_ASSERT_UNKNOWN( NumVar(AbsOp) == 1 );
    46         CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
    47         CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
     46        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
     47        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
     48        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     49        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    4850
    49         // Taylor coefficients corresponding to argument
    50         Base *y = taylor + arg[0] * nc_taylor;
    51 
    52         // Taylor coefficients corresponding to result
    53         Base *z = taylor + i_z * nc_taylor;
     51        // Taylor coefficients corresponding to argument and result
     52        Base* x = taylor + i_x * nc_taylor;
     53        Base* z = taylor + i_z * nc_taylor;
    5454
    5555        // order that decides positive, negative or zero
    56         size_t k;
    5756        k = 0;
    58         while( (k < p) & (y[k] == zero) )
     57        while( (k < j) & (x[k] == zero) )
    5958                k++;
    6059
    61         if( GreaterThanZero(y[k]) )
    62                 z[p]  = y[p];
    63         else if( LessThanZero(y[k]) )
    64                 z[p] = -y[p];
    65         else    z[p] = zero;
     60        if( GreaterThanZero(x[k]) )
     61                z[j]  = x[j];
     62        else if( LessThanZero(x[k]) )
     63                z[j] = -x[j];
     64        else    z[j] = zero;
    6665}
    6766
    6867/*!
    69 Zero order forward mode Taylor coefficient for result of op = AbsOp.
     68Compute zero order forward mode Taylor coefficient for result of op = AbsOp.
    7069
    7170The C++ source code corresponding to this operation is
    7271\verbatim
    73         z = abs(y)
     72        z = abs(x)
    7473\endverbatim
    7574
    76 \copydetails forward_unary_op_0
     75\copydetails forward_unary1_op_0
    7776*/
    7877template <class Base>
    7978inline void forward_abs_op_0(
    8079        size_t i_z         ,
    81         const size_t *arg  ,
     80        size_t i_x         ,
    8281        size_t nc_taylor   ,
    83         Base   *taylor     )
     82        Base*  taylor      )
    8483{
    8584
    8685        // check assumptions
    87         CPPAD_ASSERT_UNKNOWN( NumInd(AbsOp) == 1 );
    88         CPPAD_ASSERT_UNKNOWN( NumVar(AbsOp) == 1 );
    89         CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     86        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
     87        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
     88        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    9089        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    9190
    92         // Taylor coefficients corresponding to argument
    93         Base y0 = *(taylor + arg[0] * nc_taylor);
    94 
    95         // Taylor coefficients corresponding to result
    96         Base *z = taylor + i_z * nc_taylor;
     91        // Taylor coefficients corresponding to argument and result
     92        Base y0 = *(taylor + i_x * nc_taylor);
     93        Base* z = taylor + i_z * nc_taylor;
    9794
    9895        if( LessThanZero(y0) )
     
    10198}
    10299/*!
    103 Reverse mode partial derivatives for result of op = AbsOp.
     100Compute reverse mode partial derivatives for result of op = AbsOp.
    104101
    105102The C++ source code corresponding to this operation is
    106103\verbatim
    107         z = abs(y)
     104        z = abs(x)
    108105\endverbatim
    109106
    110 \copydetails reverse_unary_op
     107\copydetails reverse_unary1_op
    111108*/
    112109
    113110template <class Base>
    114111inline void reverse_abs_op(
    115         size_t p            ,
    116         size_t i_z          ,
    117         const size_t *arg   ,
    118         size_t nc_taylor    ,
    119         const Base  *taylor ,
    120         size_t nc_partial   ,
    121         Base   *partial     )
     112        size_t      d            ,
     113        size_t      i_z          ,
     114        size_t      i_x          ,
     115        size_t      nc_taylor    ,
     116        const Base* taylor      ,
     117        size_t      nc_partial   ,
     118        Base*       partial      )
    122119{       size_t j, k;   
    123120        static Base zero(0);
     
    125122
    126123        // check assumptions
    127         CPPAD_ASSERT_UNKNOWN( NumInd(AbsOp) == 1 );
    128         CPPAD_ASSERT_UNKNOWN( NumVar(AbsOp) == 1 );
    129         CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
    130         CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
    131         CPPAD_ASSERT_UNKNOWN( p < nc_partial );
     124        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
     125        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
     126        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     127        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     128        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    132129
    133130        // Taylor coefficients and partials corresponding to argument
    134         const Base *y  = taylor  + arg[0] * nc_taylor;
    135         Base *py       = partial + arg[0] * nc_partial;
     131        const Base* x  = taylor  + i_x * nc_taylor;
     132        Base* px       = partial + i_x * nc_partial;
    136133
    137134        // Taylor coefficients and partials corresponding to result
    138         Base *pz       = partial +    i_z * nc_partial;
     135        Base* pz       = partial +    i_z * nc_partial;
    139136
    140137        // order that decides positive, negative or zero
    141138        k = 0;
    142         while( (k < p) & (y[k] == zero) )
     139        while( (k < d) & (x[k] == zero) )
    143140                k++;
    144141
    145         if( GreaterThanZero(y[k]) )
     142        if( GreaterThanZero(x[k]) )
    146143        {       // partial of z w.r.t y is +1
    147                 for(j = k; j <= p; j++)
    148                         py[j] += pz[j];
     144                for(j = k; j <= d; j++)
     145                        px[j] += pz[j];
    149146        }
    150         else if( LessThanZero(y[k]) )
     147        else if( LessThanZero(x[k]) )
    151148        {       // partial of z w.r.t y is -1
    152                 for(j = k; j <= p; j++)
    153                         py[j] -= pz[j];
     149                for(j = k; j <= d; j++)
     150                        px[j] -= pz[j];
    154151        }
    155152}
  • trunk/cppad/local/acos_op.hpp

    r1369 r1447  
    22# ifndef CPPAD_ACOS_OP_INCLUDED
    33# define CPPAD_ACOS_OP_INCLUDED
     4CPPAD_BEGIN_NAMESPACE
    45
    56/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     7CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    78
    89CppAD is distributed under multiple licenses. This distribution is under
     
    1415-------------------------------------------------------------------------- */
    1516
    16 /*
    17 $begin ForAcosOp$$ $comment CppAD Developer Documentation$$
    18 $spell
    19         sqrt
    20         acos
    21         Taylor
    22         const
    23         inline
    24         Op
    25 $$
    26 
    27 $index acos, forward$$
    28 $index forward, acos$$
    29 $index ForAcosOp$$
    30 
    31 $section Forward Mode Acos Function$$
    32 
    33 $head Syntax$$
    34 
    35 $syntax%inline void ForAcosOp(size_t %d%,
    36         %Base% *%z%, %Base% *%b%, const %Base% *%x%)%$$
    37 
    38 $head Description$$
    39 Computes the $italic d$$ order Taylor coefficient for
    40 $latex Z$$ and $latex B$$ where
    41 $syntax%
    42         %Z% = acos(%X%)
    43         %B% = \sqrt{ 1 - %X% * %X% }
    44 %$$
    45 
    46 $head x$$
    47 The vector $italic x$$ has length $latex d+1$$ and contains the
    48 $th d$$ order Taylor coefficient row vector for $italic X$$.
    49 
    50 $head z$$
    51 The vector $italic z$$ has length $latex d+1$$.
    52 On input it contains the
    53 $th d-1$$ order Taylor coefficient row vector for $italic Z$$.
    54 On output it contains the
    55 $th d$$ order Taylor coefficient row vector for $italic Z$$; i.e.,
    56 $syntax%%z%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    57 the function $italic S$$.
    58 
    59 $head b$$
    60 The vector $italic c$$ has length $latex d+1$$.
    61 On input it contains the
    62 $th d-1$$ order Taylor coefficient row vector for $italic B$$.
    63 On output it contains the
    64 $th d$$ order Taylor coefficient row vector for $italic B$$; i.e.,
    65 $syntax%%b%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    66 the function $italic B$$.
    67 
    68 $end
    69 ------------------------------------------------------------------------------
    70 $begin RevAcosOp$$ $comment CppAD Developer Documentation$$
    71 $spell
    72         ps
    73         Acos
    74         pb
    75         Sin
    76         Taylor
    77         const
    78         inline
    79         Op
    80         px
    81         py
    82         pz
    83 $$
    84 
    85 
    86 $index acos, reverse$$
    87 $index reverse, acos$$
    88 $index RevAcosOp$$
    89 
    90 $section Reverse Mode Acos Function$$
    91 
    92 $head Syntax$$
    93 
    94 $syntax%inline void RevAcosOp(size_t %d%,
    95         const %Base% *%z%, const %Base% *%b%, const %Base% *%x%,
    96          %Base% *%pz%, %Base% *%pb%, %Base% *%px%)%$$
    97 
    98 $head Description$$
    99 We are given the partial derivatives for a function
    100 $latex G(z, b, x)$$ and we wish to compute the partial derivatives for
    101 the function
    102 $latex \[
    103         H(x) = G [ Z(x) , B(x) , x ]
    104 \] $$
    105 where $latex Z(x)$$ and $latex B(x)$$ are defined as the
    106 $th d$$ order Taylor coefficient row vector for $latex \arccos(x)$$
    107 and $latex 1 + x * x$$
    108 as a function of the corresponding row vector for $italic X$$; i.e.,
    109 $latex \[
    110 \begin{array}{rcl}
    111         Z & = & \arccos(X) \\
    112         B & = & 1 + X * X
    113 \end{array}
    114 \]$$
    115 Note that $italic Z$$ and $latex B$$ have
    116 been used both the original
    117 functions and for the corresponding mapping of Taylor coefficients.
    118 
    119 $head x$$
    120 The vector $italic x$$ has length $latex d+1$$ and contains the
    121 $th d$$ order Taylor coefficient row vector for $italic X$$.
    122 
    123 
    124 $head z$$
    125 The vector $italic z$$ has length $latex d+1$$ and contains
    126 $th d$$ order Taylor coefficient row vector for $italic z$$.
    127 
    128 $head b$$
    129 The vector $italic b$$ has length $latex d+1$$ and contains
    130 $th d$$ order Taylor coefficient row vector for $italic B$$.
    131 
    132 
    133 $head On Input$$
    134 
    135 $subhead px$$
    136 The vector $italic px$$ has length $latex d+1$$ and
    137 $syntax%%px%[%j%]%$$ contains the partial for $italic G$$
    138 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    139 
    140 $subhead pz$$
    141 The vector $italic pz$$ has length $latex d+1$$ and
    142 $syntax%%pz%[%j%]%$$ contains the partial for $italic G$$
    143 with respect to the $th j$$ order Taylor coefficient for $italic Z$$.
    144 
    145 $subhead pb$$
    146 The vector $italic pb$$ has length $latex d+1$$ and
    147 $syntax%%pb%[%j%]%$$ contains the partial for $italic G$$
    148 with respect to the $th j$$ order Taylor coefficient for $italic B$$.
    149 
    150 $head On Output$$
    151 
    152 $subhead px$$
    153 The vector $italic px$$ has length $latex d+1$$ and
    154 $syntax%%px%[%j%]%$$ contains the partial for $italic H$$
    155 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    156 
    157 $subhead pz$$
    158 The vector $italic ps$$ has length $latex d+1$$ and
    159 its contents are no longer specified; i.e., it has
    160 been used for work space.
    161 
    162 $subhead pb$$
    163 The vector $italic pb$$ has length $latex d+1$$ and
    164 its contents are no longer specified; i.e., it has
    165 been used for work space.
    166 
    167 $end
    168 ------------------------------------------------------------------------------
    169 */
    170 
    171 // BEGIN CppAD namespace
    172 namespace CppAD {
    173 
     17
     18/*!
     19\file acos_op.hpp
     20Forward and reverse mode calculations for z = acos(x).
     21*/
     22
     23
     24/*!
     25Compute forward mode Taylor coefficient for result of op = AcosOp.
     26
     27The C++ source code corresponding to this operation is
     28\verbatim
     29        z = acos(x)
     30\endverbatim
     31The auxillary result is
     32\verbatim
     33        y = sqrt(1 - x * x)
     34\endverbatim
     35The value of y, and its derivatives, are computed along with the value
     36and derivatives of z.
     37
     38\copydetails forward_unary2_op
     39*/
    17440template <class Base>
    175 inline void ForAcosOp(size_t j,
    176         Base *z, Base *b, const Base *x)
    177 {       size_t k;
     41inline void forward_acos_op(
     42        size_t j           ,
     43        size_t i_z         ,
     44        size_t i_x         ,
     45        size_t nc_taylor   ,
     46        Base*  taylor      )
     47{       
     48        // check assumptions
     49        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     50        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
     51        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     52        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
     53
     54        // Taylor coefficients corresponding to argument and result
     55        Base* x = taylor + i_x * nc_taylor;
     56        Base* z = taylor + i_z * nc_taylor;
     57        Base* b = z      +       nc_taylor;  // called y in documentation
     58
     59        size_t k;
    17860        Base qj;
    179 
    18061        if( j == 0 )
    18162        {       z[j] = acos( x[0] );
     
    20485}
    20586
     87/*!
     88Compute zero order forward mode Taylor coefficient for result of op = AcosOp.
     89
     90The C++ source code corresponding to this operation is
     91\verbatim
     92        z = acos(x)
     93\endverbatim
     94The auxillary result is
     95\verbatim
     96        y = sqrt( 1 - x * x )
     97\endverbatim
     98The value of y is computed along with the value of z.
     99
     100\copydetails forward_unary2_op_0
     101*/
    206102template <class Base>
    207 inline void RevAcosOp(size_t d,
    208         const Base  *z, const Base  *b, const Base *x,
    209               Base *pz,       Base *pb,       Base *px)
    210 {       size_t k;
     103inline void forward_acos_op_0(
     104        size_t i_z         ,
     105        size_t i_x         ,
     106        size_t nc_taylor   ,
     107        Base*  taylor      )
     108{
     109        // check assumptions
     110        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     111        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
     112        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     113        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     114
     115        // Taylor coefficients corresponding to argument and result
     116        Base* x = taylor + i_x * nc_taylor;
     117        Base* z = taylor + i_z * nc_taylor;
     118        Base* b = z      +       nc_taylor; // called y in documentation
     119
     120        z[0] = acos( x[0] );
     121        b[0] = sqrt( Base(1) - x[0] * x[0] );
     122}
     123/*!
     124Compute reverse mode partial derivatives for result of op = AcosOp.
     125
     126The C++ source code corresponding to this operation is
     127\verbatim
     128        z = acos(x)
     129\endverbatim
     130The auxillary result is
     131\verbatim
     132        y = sqrt( 1 - x * x )
     133\endverbatim
     134The value of y is computed along with the value of z.
     135
     136\copydetails reverse_unary2_op
     137*/
     138
     139template <class Base>
     140inline void reverse_acos_op(
     141        size_t      d            ,
     142        size_t      i_z          ,
     143        size_t      i_x          ,
     144        size_t      nc_taylor    ,
     145        const Base* taylor       ,
     146        size_t      nc_partial   ,
     147        Base*       partial      )
     148{
     149        // check assumptions
     150        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     151        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
     152        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     153        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     154        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     155
     156        // Taylor coefficients and partials corresponding to argument
     157        const Base* x  = taylor  + i_x * nc_taylor;
     158        Base* px       = partial + i_x * nc_partial;
     159
     160        // Taylor coefficients and partials corresponding to first result
     161        const Base* z  = taylor  + i_z * nc_taylor;
     162        Base* pz       = partial + i_z * nc_partial;
     163
     164        // Taylor coefficients and partials corresponding to auxillary result
     165        const Base* b  = z  + nc_taylor; // called y in documentation
     166        Base* pb       = pz + nc_partial;
    211167
    212168        // number of indices to access
    213169        size_t j = d;
    214 
     170        size_t k;
    215171        while(j)
    216172        {
     
    250206}
    251207
    252 } // END CppAD namespace
    253 
     208CPPAD_END_NAMESPACE
    254209# endif
  • trunk/cppad/local/ad_tape.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    223223{       size_t z_taddr;
    224224        size_t ind;
    225         CPPAD_ASSERT_UNKNOWN( NumVar(ParOp) == 1 );
    226         CPPAD_ASSERT_UNKNOWN( NumInd(ParOp) == 1 );
     225        CPPAD_ASSERT_UNKNOWN( NumRes(ParOp) == 1 );
     226        CPPAD_ASSERT_UNKNOWN( NumArg(ParOp) == 1 );
    227227        z_taddr = Rec_.PutOp(ParOp);
    228228        ind     = Rec_.PutPar(z);
    229         Rec_.PutInd(ind);
     229        Rec_.PutArg(ind);
    230230
    231231        return z_taddr;
  • trunk/cppad/local/add.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5151        {       if( var_right )
    5252                {       // result = variable + variable
    53                         CPPAD_ASSERT_UNKNOWN( NumVar(AddvvOp) == 1 );
    54                         CPPAD_ASSERT_UNKNOWN( NumInd(AddvvOp) == 2 );
     53                        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
     54                        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
    5555
    5656                        // put operand addresses in tape
    57                         tape->Rec_.PutInd(left.taddr_, right.taddr_);
     57                        tape->Rec_.PutArg(left.taddr_, right.taddr_);
    5858                        // put operator in the tape
    5959                        result.taddr_ = tape->Rec_.PutOp(AddvvOp);
     
    6767                else
    6868                {       // result = variable + parameter
    69                         CPPAD_ASSERT_UNKNOWN( NumVar(AddvpOp) == 1 );
    70                         CPPAD_ASSERT_UNKNOWN( NumInd(AddvpOp) == 2 );
     69                        CPPAD_ASSERT_UNKNOWN( NumRes(AddvpOp) == 1 );
     70                        CPPAD_ASSERT_UNKNOWN( NumArg(AddvpOp) == 2 );
    7171
    7272                        // put operand addresses in tape
    7373                        size_t p = tape->Rec_.PutPar(right.value_);
    74                         tape->Rec_.PutInd(left.taddr_, p);
     74                        tape->Rec_.PutArg(left.taddr_, p);
    7575                        // put operator in the tape
    7676                        result.taddr_ = tape->Rec_.PutOp(AddvpOp);
     
    8686                else
    8787                {       // result = parameter + variable
    88                         CPPAD_ASSERT_UNKNOWN( NumVar(AddpvOp) == 1 );
    89                         CPPAD_ASSERT_UNKNOWN( NumInd(AddpvOp) == 2 );
     88                        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
     89                        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
    9090
    9191                        // put operand addresses in tape
    9292                        size_t p = tape->Rec_.PutPar(left.value_);
    93                         tape->Rec_.PutInd(p, right.taddr_);
     93                        tape->Rec_.PutArg(p, right.taddr_);
    9494                        // put operator in the tape
    9595                        result.taddr_ = tape->Rec_.PutOp(AddpvOp);
  • trunk/cppad/local/add_eq.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5050        {       if( var_right )
    5151                {       // this = variable + variable
    52                         CPPAD_ASSERT_UNKNOWN( NumVar(AddvvOp) == 1 );
    53                         CPPAD_ASSERT_UNKNOWN( NumInd(AddvvOp) == 2 );
     52                        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
     53                        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
    5454
    5555                        // put operand addresses in tape
    56                         tape->Rec_.PutInd(taddr_, right.taddr_);
     56                        tape->Rec_.PutArg(taddr_, right.taddr_);
    5757                        // put operator in the tape
    5858                        taddr_ = tape->Rec_.PutOp(AddvvOp);
     
    6262                else if( ! IdenticalZero( right.value_ ) )
    6363                {       // this = variable + parameter
    64                         CPPAD_ASSERT_UNKNOWN( NumVar(AddvpOp) == 1 );
    65                         CPPAD_ASSERT_UNKNOWN( NumInd(AddvpOp) == 2 );
     64                        CPPAD_ASSERT_UNKNOWN( NumRes(AddvpOp) == 1 );
     65                        CPPAD_ASSERT_UNKNOWN( NumArg(AddvpOp) == 2 );
    6666
    6767                        // put operand addresses in tape
    6868                        size_t p = tape->Rec_.PutPar(right.value_);
    69                         tape->Rec_.PutInd(taddr_, p);
     69                        tape->Rec_.PutArg(taddr_, p);
    7070                        // put operator in the tape
    7171                        taddr_ = tape->Rec_.PutOp(AddvpOp);
     
    8181                else
    8282                {       // this = parameter + variable
    83                         CPPAD_ASSERT_UNKNOWN( NumVar(AddpvOp) == 1 );
    84                         CPPAD_ASSERT_UNKNOWN( NumInd(AddpvOp) == 2 );
     83                        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
     84                        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
    8585
    8686                        // put operand addresses in tape
    8787                        size_t p = tape->Rec_.PutPar(left);
    88                         tape->Rec_.PutInd(p, right.taddr_);
     88                        tape->Rec_.PutArg(p, right.taddr_);
    8989                        // put operator in the tape
    9090                        taddr_ = tape->Rec_.PutOp(AddpvOp);
  • trunk/cppad/local/add_op.hpp

    r1369 r1447  
    22# ifndef CPPAD_ADD_OP_INCLUDED
    33# define CPPAD_ADD_OP_INCLUDED
     4CPPAD_BEGIN_NAMESPACE
    45
    56/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     7CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    78
    89CppAD is distributed under multiple licenses. This distribution is under
     
    1415-------------------------------------------------------------------------- */
    1516
    16 /*
    17 $begin ForAddOp$$ $comment CppAD Developer Documentation$$
    18 $spell
    19         Addpv
    20         Addvp
    21         Addvv
    22         Taylor
    23         const
    24         inline
    25         Op
    26 $$
    27 
    28 $index add, forward operator$$
    29 $index forward, add operator$$
    30 $index operator, add forward$$
    31 $index ForAdd$$
    32 
    33 $section Forward Mode Addition Operators$$
    34 
    35 $head Syntax$$
    36 
    37 $syntax%inline void ForAddvvOp(size_t %d%,
    38         %Base% *%z%, const %Base% *%x%, const %Base% *%y%)%$$
    39 $pre
    40 $$
    41 $syntax%inline void ForAddpvOp(size_t %d%,
    42         %Base% *%z%, const %Base% *%p%, const %Base% *%x%)%$$
    43 $pre
    44 $$
    45 $syntax%inline void ForAddvpOp(size_t %d%,
    46         %Base% *%z%, const %Base% *%x%, const %Base% *%p%)%$$
    47 
    48 
    49 $head Description$$
    50 Computes the $italic d$$ order Taylor coefficient for $latex Z$$ where
    51 $table
    52 Operation  $cnext Value  $rnext
    53 Addvv      $cnext $latex Z = X + Y$$ $rnext
    54 Addpv      $cnext $latex Z = P + Y$$ $rnext
    55 Addvp      $cnext $latex Z = X + P$$
    56 $tend
    57 
    58 $head x$$
    59 The vector $italic x$$ has length $latex d+1$$ and contains the
    60 $th d$$ order Taylor coefficient row vector for $italic X$$.
    61 
    62 $head y$$
    63 The vector $italic y$$ has length $latex d+1$$ and contains the
    64 $th d$$ order Taylor coefficient row vector for $italic Y$$.
    65 
    66 $head p$$
    67 The scalar $syntax%*%p%$$ contains the value of the parameter $italic P$$.
    68 
    69 
    70 $head z$$
    71 The vector $italic z$$ has length $latex d+1$$.
    72 On input it contains the
    73 $th d-1$$ order Taylor coefficient row vector for $italic Z$$.
    74 On output it contains the
    75 $th d$$ order Taylor coefficient row vector for $italic Z$$; i.e.,
    76 $syntax%%z%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    77 the function $italic Z$$.
    78 
    79 $end
    80 ------------------------------------------------------------------------------
    81 $begin RevAddOp$$ $comment CppAD Developer Documentation$$
    82 $spell
    83         Addpv
    84         Addvp
    85         Addvv
    86         Taylor
    87         const
    88         inline
    89         Op
    90         px
    91         py
    92         pz
    93 $$
    94 
    95 
    96 $index add, reverse operator$$
    97 $index reverse, add operator$$
    98 $index operator, add reverse$$
    99 $index RevAdd$$
    100 $section Reverse Mode Addition Operator$$
    101 
    102 $head Syntax$$
    103 
    104 $syntax%inline void RevAddvvOp(size_t %d%,
    105         const %Base% *%pz%, %Base% *%px%, %Base% *%py%)%$$
    106 $pre
    107 $$
    108 $syntax%inline void RevAddpvOp(size_t %d%,
    109         const %Base% *%pz%, %Base% *%px%)%$$
    110 $pre
    111 $$
    112 $syntax%inline void RevAddvpOp(size_t %d%,
    113         const %Base% *%pz%, %Base% *%py%)%$$
    114 
    115 $head Description$$
    116 We are given the partial derivatives for a function
    117 $latex G(z, x, y)$$ and we wish to compute the partial derivatives for
    118 the function
    119 $latex \[
    120         H(x, y) = G [ Z(x, y) , x , y ]
    121 \]$$
    122 where $latex Z(x, y)$$ is defined as the
    123 $th d$$ order Taylor coefficient row vector for $italic Z$$ as
    124 a function of the corresponding vectors for
    125 $italic X$$ and $italic Y$$ where
    126 
    127 $table
    128 Operation  $cnext Value  $rnext
    129 Addvv      $cnext $latex Z = X + Y$$ $rnext
    130 Addpv      $cnext $latex Z = P + Y$$ $rnext
    131 Addvp      $cnext $latex Z = X + P$$
    132 $tend
    133 
    134 Note that $italic Z$$ has been used both the original addition
    135 function and for the corresponding mapping of Taylor coefficients.
    136 
    137 $head pz$$
    138 The vector $italic pz$$ has length $latex d+1$$ and
    139 $syntax%%pz%[%j%]%$$ contains the partial for $italic G$$
    140 with respect to the $th j$$ order Taylor coefficient for $italic Z$$.
    141 
    142 $head On Input$$
    143 
    144 $subhead px$$
    145 The vector $italic px$$ has length $latex d+1$$ and
    146 $syntax%%px%[%j%]%$$ contains the partial for $italic G$$
    147 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    148 
    149 $subhead py$$
    150 The vector $italic py$$ has length $latex d+1$$ and
    151 $syntax%%py%[%j%]%$$ contains the partial for $italic G$$
    152 with respect to the $th j$$ order Taylor coefficient for $italic Y$$.
    153 
    154 $head On Output$$
    155 
    156 $subhead px$$
    157 If present,
    158 the vector $italic px$$ has length $latex d+1$$ and
    159 $syntax%%px%[%j%]%$$ contains the partial for $italic H$$
    160 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    161 
    162 $subhead py$$
    163 If present,
    164 the vector $italic py$$ has length $latex d+1$$ and
    165 $syntax%%py%[%j%]%$$ contains the partial for $italic H$$
    166 with respect to the $th j$$ order Taylor coefficient for $italic Y$$.
    167 
    168 
    169 $end
    170 ------------------------------------------------------------------------------
    171 */
    172 
    173 // BEGIN CppAD namespace
    174 namespace CppAD {
     17/*!
     18\file add_op.hpp
     19Forward and reverse mode calculations for z = x + y.
     20*/
    17521
    17622// --------------------------- Addvv -----------------------------------------
    177 
    178 template <class Base>
    179 inline void ForAddvvOp(size_t d,
    180         Base *z, const Base *x, const Base *y)
    181 {
     23/*!
     24Compute forward mode Taylor coefficients for result of op = AddvvOp.
     25
     26The C++ source code corespnding to this operation is
     27\verbatim
     28        z = x + y
     29\endverbatim
     30In the documentation below,
     31this operations is for the case where both x and y are variables
     32and the argument \a parameter is not used.
     33
     34\copydetails forward_binary_op
     35*/
     36
     37template <class Base>
     38inline void forward_addvv_op(
     39        size_t        d           ,
     40        size_t        i_z         ,
     41        const size_t* arg         ,
     42        const Base*   parameter   ,
     43        size_t        nc_taylor   ,
     44        Base*         taylor      )
     45{
     46        // check assumptions
     47        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
     48        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
     49        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     50        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     51        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     52
     53        // Taylor coefficients corresponding to arguments and result
     54        Base* x = taylor + arg[0] * nc_taylor;
     55        Base* y = taylor + arg[1] * nc_taylor;
     56        Base* z = taylor + i_z    * nc_taylor;
     57
    18258        z[d] = x[d] + y[d];
    18359}
    18460
    185 template <class Base>
    186 inline void RevAddvvOp(size_t d,
    187         const Base *pz, Base *px, Base *py)
    188 {
     61/*!
     62Compute zero order forward mode Taylor coefficients for result of op = AddvvOp.
     63
     64The C++ source code corespnding to this operation is
     65\verbatim
     66        z = x + y
     67\endverbatim
     68In the documentation below,
     69this operations is for the case where both x and y are variables
     70and the argument \a parameter is not used.
     71
     72\copydetails forward_binary_op_0
     73*/
     74
     75template <class Base>
     76inline void forward_addvv_op_0(
     77        size_t        i_z         ,
     78        const size_t* arg         ,
     79        const Base*   parameter   ,
     80        size_t        nc_taylor   ,
     81        Base*         taylor      )
     82{
     83        // check assumptions
     84        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
     85        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
     86        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     87        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     88
     89        // Taylor coefficients corresponding to arguments and result
     90        Base* x = taylor + arg[0] * nc_taylor;
     91        Base* y = taylor + arg[1] * nc_taylor;
     92        Base* z = taylor + i_z    * nc_taylor;
     93
     94        z[0] = x[0] + y[0];
     95}
     96
     97/*!
     98Compute reverse mode partial derivatives for result of op = AddvvOp.
     99
     100The C++ source code corespnding to this operation is
     101\verbatim
     102        z = x + y
     103\endverbatim
     104In the documentation below,
     105this operations is for the case where both x and y are variables
     106and the argument \a parameter is not used.
     107
     108\copydetails reverse_binary_op
     109*/
     110
     111template <class Base>
     112inline void reverse_addvv_op(
     113        size_t        d           ,
     114        size_t        i_z         ,
     115        const size_t* arg         ,
     116        const Base*   parameter   ,
     117        size_t        nc_taylor   ,
     118        const Base*   taylor      ,
     119        size_t        nc_partial  ,
     120        Base*         partial     )
     121{
     122        // check assumptions
     123        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
     124        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
     125        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     126        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     127        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     128        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     129
     130        // Partial derivatives corresponding to arguments and result
     131        Base* px = partial + arg[0] * nc_partial;
     132        Base* py = partial + arg[1] * nc_partial;
     133        Base* pz = partial + i_z    * nc_partial;
     134
    189135        // number of indices to access
    190136        size_t i = d + 1;
    191 
    192137        while(i)
    193138        {       --i;
     
    198143
    199144// --------------------------- Addpv -----------------------------------------
    200 
    201 template <class Base>
    202 inline void ForAddpvOp(size_t d,
    203         Base *z, const Base *p, const Base *y)
    204 {
     145/*!
     146Compute forward mode Taylor coefficients for result of op = AddpvOp.
     147
     148The C++ source code corespnding to this operation is
     149\verbatim
     150        z = x + y
     151\endverbatim
     152In the documentation below,
     153this operations is for the case where x is a parameter and y is a variable.
     154
     155\copydetails forward_binary_op
     156*/
     157
     158template <class Base>
     159inline void forward_addpv_op(
     160        size_t        d           ,
     161        size_t        i_z         ,
     162        const size_t* arg         ,
     163        const Base*   parameter   ,
     164        size_t        nc_taylor   ,
     165        Base*         taylor      )
     166{
     167        // check assumptions
     168        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
     169        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
     170        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     171        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     172
     173        // Taylor coefficients corresponding to arguments and result
     174        Base* y = taylor + arg[1] * nc_taylor;
     175        Base* z = taylor + i_z    * nc_taylor;
     176
     177# if CPPAD_USE_FORWARD0SWEEP
     178        CPPAD_ASSERT_UNKNOWN( d > 0 );
     179        z[d] = y[d];
     180# else
     181        // Paraemter value
     182        Base x = parameter[ arg[0] ];
    205183        if( d == 0 )
    206                 z[d] = (*p) + y[d];
     184                z[d] = x + y[d];
    207185        else    z[d] = y[d];
    208 
    209 }
    210 
    211 template <class Base>
    212 inline void RevAddpvOp(size_t d,
    213         const Base *pz, Base *py)
    214 {
     186# endif
     187}
     188/*!
     189Compute zero order forward mode Taylor coefficient for result of op = AddpvOp.
     190
     191The C++ source code corespnding to this operation is
     192\verbatim
     193        z = x + y
     194\endverbatim
     195In the documentation below,
     196this operations is for the case where x is a parameter and y is a variable.
     197
     198\copydetails forward_binary_op_0
     199*/
     200
     201template <class Base>
     202inline void forward_addpv_op_0(
     203        size_t        i_z         ,
     204        const size_t* arg         ,
     205        const Base*   parameter   ,
     206        size_t        nc_taylor   ,
     207        Base*         taylor      )
     208{
     209        // check assumptions
     210        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
     211        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
     212        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     213
     214        // Paraemter value
     215        Base x = parameter[ arg[0] ];
     216
     217        // Taylor coefficients corresponding to arguments and result
     218        Base* y = taylor + arg[1] * nc_taylor;
     219        Base* z = taylor + i_z    * nc_taylor;
     220
     221        z[0] = x + y[0];
     222}
     223
     224/*!
     225Compute reverse mode partial derivative for result of op = AddpvOp.
     226
     227The C++ source code corespnding to this operation is
     228\verbatim
     229        z = x + y
     230\endverbatim
     231In the documentation below,
     232this operations is for the case where x is a parameter and y is a variable.
     233
     234\copydetails reverse_binary_op
     235*/
     236
     237template <class Base>
     238inline void reverse_addpv_op(
     239        size_t        d           ,
     240        size_t        i_z         ,
     241        const size_t* arg         ,
     242        const Base*   parameter   ,
     243        size_t        nc_taylor   ,
     244        const Base*   taylor      ,
     245        size_t        nc_partial  ,
     246        Base*         partial     )
     247{
     248        // check assumptions
     249        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
     250        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
     251        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     252        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     253        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     254
     255        // Partial derivatives corresponding to arguments and result
     256        Base* py = partial + arg[1] * nc_partial;
     257        Base* pz = partial + i_z    * nc_partial;
     258
    215259        // number of indices to access
    216260        size_t i = d + 1;
    217 
    218261        while(i)
    219262        {       --i;
     
    223266
    224267// --------------------------- Addvp -----------------------------------------
    225 
    226 template <class Base>
    227 inline void ForAddvpOp(size_t d,
    228         Base *z, const Base *x, const Base *p)
    229 {
     268/*!
     269Compute forward mode Taylor coefficients for result of op = AddvvOp.
     270
     271The C++ source code corespnding to this operation is
     272\verbatim
     273        z = x + y
     274\endverbatim
     275In the documentation below,
     276this operations is for the case where x is a variable and y is a parameter.
     277
     278\copydetails forward_binary_op
     279*/
     280
     281template <class Base>
     282inline void forward_addvp_op(
     283        size_t        d           ,
     284        size_t        i_z         ,
     285        const size_t* arg         ,
     286        const Base*   parameter   ,
     287        size_t        nc_taylor   ,
     288        Base*         taylor      )
     289{
     290        // check assumptions
     291        CPPAD_ASSERT_UNKNOWN( NumArg(AddvpOp) == 2 );
     292        CPPAD_ASSERT_UNKNOWN( NumRes(AddvpOp) == 1 );
     293        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     294        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     295
     296        // Taylor coefficients corresponding to arguments and result
     297        Base* x = taylor + arg[0] * nc_taylor;
     298        Base* z = taylor + i_z    * nc_taylor;
     299
     300# if CPPAD_USE_FORWARD0SWEEP
     301        CPPAD_ASSERT_UNKNOWN( d > 0 );
     302        z[d] = x[d];
     303# else
     304        // Parameter value
     305        Base y = parameter[ arg[1] ];
    230306        if( d == 0 )
    231                 z[d] = x[d] + (*p);
     307                z[d] = x[d] + y;
    232308        else    z[d] = x[d];
    233 
    234 }
    235 
    236 template <class Base>
    237 inline void RevAddvpOp(size_t d,
    238         const Base *pz, Base *px)
    239 {
     309# endif
     310}
     311
     312/*!
     313Compute zero order forward mode Taylor coefficients for result of op = AddvvOp.
     314
     315The C++ source code corespnding to this operation is
     316\verbatim
     317        z = x + y
     318\endverbatim
     319In the documentation below,
     320this operations is for the case where x is a variable and y is a parameter.
     321
     322\copydetails forward_binary_op_0
     323*/
     324
     325template <class Base>
     326inline void forward_addvp_op_0(
     327        size_t        i_z         ,
     328        const size_t* arg         ,
     329        const Base*   parameter   ,
     330        size_t        nc_taylor   ,
     331        Base*         taylor      )
     332{
     333        // check assumptions
     334        CPPAD_ASSERT_UNKNOWN( NumArg(AddvpOp) == 2 );
     335        CPPAD_ASSERT_UNKNOWN( NumRes(AddvpOp) == 1 );
     336        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     337
     338        // Parameter value
     339        Base y = parameter[ arg[1] ];
     340
     341        // Taylor coefficients corresponding to arguments and result
     342        Base* x = taylor + arg[0] * nc_taylor;
     343        Base* z = taylor + i_z    * nc_taylor;
     344
     345        z[0] = x[0] + y;
     346}
     347
     348/*!
     349Compute reverse mode partial derivative for result of op = AddvpOp.
     350
     351The C++ source code corespnding to this operation is
     352\verbatim
     353        z = x + y
     354\endverbatim
     355In the documentation below,
     356this operations is for the case where x is a variable and y is a parameter.
     357
     358\copydetails reverse_binary_op
     359*/
     360
     361template <class Base>
     362inline void reverse_addvp_op(
     363        size_t        d           ,
     364        size_t        i_z         ,
     365        const size_t* arg         ,
     366        const Base*   parameter   ,
     367        size_t        nc_taylor   ,
     368        const Base*   taylor      ,
     369        size_t        nc_partial  ,
     370        Base*         partial     )
     371{
     372        // check assumptions
     373        CPPAD_ASSERT_UNKNOWN( NumArg(AddvpOp) == 2 );
     374        CPPAD_ASSERT_UNKNOWN( NumRes(AddvpOp) == 1 );
     375        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     376        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     377        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     378
     379        // Partial derivatives corresponding to arguments and result
     380        Base* px = partial + arg[0] * nc_partial;
     381        Base* pz = partial + i_z    * nc_partial;
     382
    240383        // number of indices to access
    241384        size_t i = d + 1;
    242 
    243385        while(i)
    244386        {       --i;
     
    247389}
    248390
    249 } // END CppAD namespace
    250 
     391CPPAD_END_NAMESPACE
    251392# endif
  • trunk/cppad/local/asin_op.hpp

    r1369 r1447  
    22# ifndef CPPAD_ASIN_OP_INCLUDED
    33# define CPPAD_ASIN_OP_INCLUDED
     4CPPAD_BEGIN_NAMESPACE
    45
    56/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     7CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    78
    89CppAD is distributed under multiple licenses. This distribution is under
     
    1415-------------------------------------------------------------------------- */
    1516
    16 /*
    17 $begin ForAsinOp$$ $comment CppAD Developer Documentation$$
    18 $spell
    19         sqrt
    20         asin
    21         Taylor
    22         const
    23         inline
    24         Op
    25 $$
    26 
    27 $index asin, forward$$
    28 $index forward, asin$$
    29 $index ForAsinOp$$
    30 
    31 $section Forward Mode Asin Function$$
    32 
    33 $head Syntax$$
    34 
    35 $syntax%inline void ForAsinOp(size_t %d%,
    36         %Base% *%z%, %Base% *%b%, const %Base% *%x%)%$$
    37 
    38 $head Description$$
    39 Computes the $italic d$$ order Taylor coefficient for
    40 $latex Z$$ and $latex B$$ where
    41 $syntax%
    42         %Z% = asin(%X%)
    43         %B% = \sqrt{ 1 - %X% * %X% }
    44 %$$
    45 
    46 $head x$$
    47 The vector $italic x$$ has length $latex d+1$$ and contains the
    48 $th d$$ order Taylor coefficient row vector for $italic X$$.
    49 
    50 $head z$$
    51 The vector $italic z$$ has length $latex d+1$$.
    52 On input it contains the
    53 $th d-1$$ order Taylor coefficient row vector for $italic Z$$.
    54 On output it contains the
    55 $th d$$ order Taylor coefficient row vector for $italic Z$$; i.e.,
    56 $syntax%%z%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    57 the function $italic S$$.
    58 
    59 $head b$$
    60 The vector $italic c$$ has length $latex d+1$$.
    61 On input it contains the
    62 $th d-1$$ order Taylor coefficient row vector for $italic B$$.
    63 On output it contains the
    64 $th d$$ order Taylor coefficient row vector for $italic B$$; i.e.,
    65 $syntax%%b%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    66 the function $italic B$$.
    67 
    68 $end
    69 ------------------------------------------------------------------------------
    70 $begin RevAsinOp$$ $comment CppAD Developer Documentation$$
    71 $spell
    72         ps
    73         Asin
    74         pb
    75         Sin
    76         Taylor
    77         const
    78         inline
    79         Op
    80         px
    81         py
    82         pz
    83 $$
    84 
    85 $index reverse, asin$$
    86 $index asin, reverse$$
    87 $index RevAsinOp$$
    88 
    89 $section Reverse Mode Asin Function$$
    90 
    91 $head Syntax$$
    92 
    93 $syntax%inline void RevAsinOp(size_t %d%,
    94         const %Base% *%z%, const %Base% *%b%, const %Base% *%x%,
    95          %Base% *%pz%, %Base% *%pb%, %Base% *%px%)%$$
    96 
    97 $head Description$$
    98 We are given the partial derivatives for a function
    99 $latex G(z, b, x)$$ and we wish to compute the partial derivatives for
    100 the function
    101 $latex \[
    102         H(x) = G [ Z(x) , B(x) , x ]
    103 \] $$
    104 where $latex Z(x)$$ and $latex B(x)$$ are defined as the
    105 $th d$$ order Taylor coefficient row vector for $latex \arcsin(x)$$
    106 and $latex 1 + x * x$$
    107 as a function of the corresponding row vector for $italic X$$; i.e.,
    108 $latex \[
    109 \begin{array}{rcl}
    110         Z & = & \arcsin(X) \\
    111         B & = & 1 + X * X
    112 \end{array}
    113 \]$$
    114 Note that $italic Z$$ and $latex B$$ have
    115 been used both the original
    116 functions and for the corresponding mapping of Taylor coefficients.
    117 
    118 $head x$$
    119 The vector $italic x$$ has length $latex d+1$$ and contains the
    120 $th d$$ order Taylor coefficient row vector for $italic X$$.
    121 
    122 
    123 $head z$$
    124 The vector $italic z$$ has length $latex d+1$$ and contains
    125 $th d$$ order Taylor coefficient row vector for $italic z$$.
    126 
    127 $head b$$
    128 The vector $italic b$$ has length $latex d+1$$ and contains
    129 $th d$$ order Taylor coefficient row vector for $italic B$$.
    130 
    131 
    132 $head On Input$$
    133 
    134 $subhead px$$
    135 The vector $italic px$$ has length $latex d+1$$ and
    136 $syntax%%px%[%j%]%$$ contains the partial for $italic G$$
    137 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    138 
    139 $subhead pz$$
    140 The vector $italic pz$$ has length $latex d+1$$ and
    141 $syntax%%pz%[%j%]%$$ contains the partial for $italic G$$
    142 with respect to the $th j$$ order Taylor coefficient for $italic Z$$.
    143 
    144 $subhead pb$$
    145 The vector $italic pb$$ has length $latex d+1$$ and
    146 $syntax%%pb%[%j%]%$$ contains the partial for $italic G$$
    147 with respect to the $th j$$ order Taylor coefficient for $italic B$$.
    148 
    149 $head On Output$$
    150 
    151 $subhead px$$
    152 The vector $italic px$$ has length $latex d+1$$ and
    153 $syntax%%px%[%j%]%$$ contains the partial for $italic H$$
    154 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    155 
    156 $subhead pz$$
    157 The vector $italic ps$$ has length $latex d+1$$ and
    158 its contents are no longer specified; i.e., it has
    159 been used for work space.
    160 
    161 $subhead pb$$
    162 The vector $italic pb$$ has length $latex d+1$$ and
    163 its contents are no longer specified; i.e., it has
    164 been used for work space.
    165 
    166 $end
    167 ------------------------------------------------------------------------------
    168 */
    169 
    170 // BEGIN CppAD namespace
    171 namespace CppAD {
    172 
     17
     18/*!
     19\file asin_op.hpp
     20Forward and reverse mode calculations for z = asin(x).
     21*/
     22
     23
     24/*!
     25Compute forward mode Taylor coefficient for result of op = AsinOp.
     26
     27The C++ source code corresponding to this operation is
     28\verbatim
     29        z = asin(x)
     30\endverbatim
     31The auxillary result is
     32\verbatim
     33        y = sqrt(1 - x * x)
     34\endverbatim
     35The value of y, and its derivatives, are computed along with the value
     36and derivatives of z.
     37
     38\copydetails forward_unary2_op
     39*/
    17340template <class Base>
    174 inline void ForAsinOp(size_t j,
    175         Base *z, Base *b, const Base *x)
    176 {       size_t k;
     41inline void forward_asin_op(
     42        size_t j           ,
     43        size_t i_z         ,
     44        size_t i_x         ,
     45        size_t nc_taylor   ,
     46        Base*  taylor      )
     47{       
     48        // check assumptions
     49        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
     50        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
     51        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     52        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
     53
     54        // Taylor coefficients corresponding to argument and result
     55        Base* x = taylor + i_x * nc_taylor;
     56        Base* z = taylor + i_z * nc_taylor;
     57        Base* b = z      +       nc_taylor;  // called y in documentation
     58
     59        size_t k;
    17760        Base qj;
    178 
    17961        if( j == 0 )
    18062        {       z[j] = asin( x[0] );
     
    20385}
    20486
     87/*!
     88Compute zero order forward mode Taylor coefficient for result of op = AsinOp.
     89
     90The C++ source code corresponding to this operation is
     91\verbatim
     92        z = asin(x)
     93\endverbatim
     94The auxillary result is
     95\verbatim
     96        y = sqrt( 1 - x * x )
     97\endverbatim
     98The value of y is computed along with the value of z.
     99
     100\copydetails forward_unary2_op_0
     101*/
    205102template <class Base>
    206 inline void RevAsinOp(size_t d,
    207         const Base  *z, const Base  *b, const Base *x,
    208               Base *pz,       Base *pb,       Base *px)
    209 {       size_t k;
     103inline void forward_asin_op_0(
     104        size_t i_z         ,
     105        size_t i_x         ,
     106        size_t nc_taylor   ,
     107        Base*  taylor      )
     108{
     109        // check assumptions
     110        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
     111        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
     112        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     113        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     114
     115        // Taylor coefficients corresponding to argument and result
     116        Base* x = taylor + i_x * nc_taylor;
     117        Base* z = taylor + i_z * nc_taylor;
     118        Base* b = z      +       nc_taylor; // called y in documentation
     119
     120        z[0] = asin( x[0] );
     121        b[0] = sqrt( Base(1) - x[0] * x[0] );
     122}
     123/*!
     124Compute reverse mode partial derivatives for result of op = AsinOp.
     125
     126The C++ source code corresponding to this operation is
     127\verbatim
     128        z = asin(x)
     129\endverbatim
     130The auxillary result is
     131\verbatim
     132        y = sqrt( 1 - x * x )
     133\endverbatim
     134The value of y is computed along with the value of z.
     135
     136\copydetails reverse_unary2_op
     137*/
     138
     139template <class Base>
     140inline void reverse_asin_op(
     141        size_t      d            ,
     142        size_t      i_z          ,
     143        size_t      i_x          ,
     144        size_t      nc_taylor    ,
     145        const Base* taylor       ,
     146        size_t      nc_partial   ,
     147        Base*       partial      )
     148{
     149        // check assumptions
     150        CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
     151        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
     152        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     153        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     154        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     155
     156        // Taylor coefficients and partials corresponding to argument
     157        const Base* x  = taylor  + i_x * nc_taylor;
     158        Base* px       = partial + i_x * nc_partial;
     159
     160        // Taylor coefficients and partials corresponding to first result
     161        const Base* z  = taylor  + i_z * nc_taylor;
     162        Base* pz       = partial + i_z * nc_partial;
     163
     164        // Taylor coefficients and partials corresponding to auxillary result
     165        const Base* b  = z  + nc_taylor; // called y in documentation
     166        Base* pb       = pz + nc_partial;
    210167
    211168        // number of indices to access
    212169        size_t j = d;
    213 
     170        size_t k;
    214171        while(j)
    215172        {
     
    249206}
    250207
    251 } // END CppAD namespace
    252 
     208CPPAD_END_NAMESPACE
    253209# endif
  • trunk/cppad/local/atan_op.hpp

    r1369 r1447  
    22# ifndef CPPAD_ATAN_OP_INCLUDED
    33# define CPPAD_ATAN_OP_INCLUDED
     4CPPAD_BEGIN_NAMESPACE
    45
    56/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     7CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    78
    89CppAD is distributed under multiple licenses. This distribution is under
     
    1415-------------------------------------------------------------------------- */
    1516
    16 /*
    17 $begin ForAtanOp$$ $comment CppAD Developer Documentation$$
    18 $spell
    19         atan
    20         Taylor
    21         const
    22         inline
    23         Op
    24 $$
    2517
    26 $index forward, atan$$
    27 $index atan, forward$$
    28 $index ForAtanOp$$
    29 
    30 $section Forward Mode Atan Function$$
    31 
    32 $head Syntax$$
    33 
    34 $syntax%inline void ForAtanOp(size_t %d%,
    35         %Base% *%z%, %Base% *%b%, const %Base% *%x%)%$$
    36 
    37 $head Description$$
    38 Computes the $italic d$$ order Taylor coefficient for
    39 $latex Z$$ and $latex B$$ where
    40 $syntax%
    41         %Z% = atan(%X%)
    42         %B% = 1 + %X% * %X%
    43 %$$
    44 
    45 $head x$$
    46 The vector $italic x$$ has length $latex d+1$$ and contains the
    47 $th d$$ order Taylor coefficient row vector for $italic X$$.
    48 
    49 $head z$$
    50 The vector $italic z$$ has length $latex d+1$$.
    51 On input it contains the
    52 $th d-1$$ order Taylor coefficient row vector for $italic Z$$.
    53 On output it contains the
    54 $th d$$ order Taylor coefficient row vector for $italic Z$$; i.e.,
    55 $syntax%%z%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    56 the function $italic S$$.
    57 
    58 $head b$$
    59 The vector $italic c$$ has length $latex d+1$$.
    60 On input it contains the
    61 $th d-1$$ order Taylor coefficient row vector for $italic B$$.
    62 On output it contains the
    63 $th d$$ order Taylor coefficient row vector for $italic B$$; i.e.,
    64 $syntax%%b%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    65 the function $italic B$$.
    66 
    67 $end
    68 ------------------------------------------------------------------------------
    69 $begin RevAtanOp$$ $comment CppAD Developer Documentation$$
    70 $spell
    71         ps
    72         Atan
    73         pb
    74         Sin
    75         Taylor
    76         const
    77         inline
    78         Op
    79         px
    80         py
    81         pz
    82 $$
     18/*!
     19\file atan_op.hpp
     20Forward and reverse mode calculations for z = atan(x).
     21*/
    8322
    8423
    85 $index reverse, atan$$
    86 $index atan, reverse$$
    87 $index RevAtanOp$$
     24/*!
     25Forward mode Taylor coefficient for result of op = AtanOp.
    8826
    89 $section Reverse Mode Atan Function$$
     27The C++ source code corresponding to this operation is
     28\verbatim
     29        z = atan(x)
     30\endverbatim
     31The auxillary result is
     32\verbatim
     33        y = 1 + x * x
     34\endverbatim
     35The value of y, and its derivatives, are computed along with the value
     36and derivatives of z.
    9037
    91 $head Syntax$$
     38\copydetails forward_unary2_op
     39*/
     40template <class Base>
     41inline void forward_atan_op(
     42        size_t j           ,
     43        size_t i_z         ,
     44        size_t i_x         ,
     45        size_t nc_taylor   ,
     46        Base*  taylor      )
     47{       
     48        // check assumptions
     49        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
     50        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
     51        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     52        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    9253
    93 $syntax%inline void RevAtanOp(size_t %d%,
    94         const %Base% *%z%, const %Base% *%b%, const %Base% *%x%,
    95          %Base% *%pz%, %Base% *%pb%, %Base% *%px%)%$$
     54        // Taylor coefficients corresponding to argument and result
     55        Base* x = taylor + i_x * nc_taylor;
     56        Base* z = taylor + i_z * nc_taylor;
     57        Base* b = z      +       nc_taylor;  // called y in documentation
    9658
    97 $head Description$$
    98 We are given the partial derivatives for a function
    99 $latex G(z, b, x)$$ and we wish to compute the partial derivatives for
    100 the function
    101 $latex \[
    102         H(x) = G [ Z(x) , B(x) , x ]
    103 \] $$
    104 where $latex Z(x)$$ and $latex B(x)$$ are defined as the
    105 $th d$$ order Taylor coefficient row vector for $latex \arctan(x)$$
    106 and $latex 1 + x * x$$
    107 as a function of the corresponding row vector for $italic X$$; i.e.,
    108 $latex \[
    109 \begin{array}{rcl}
    110         Z & = & \arctan(X) \\
    111         B & = & 1 + X * X
    112 \end{array}
    113 \]$$
    114 Note that $italic Z$$ and $latex B$$ have
    115 been used both the original
    116 functions and for the corresponding mapping of Taylor coefficients.
    117 
    118 $head x$$
    119 The vector $italic x$$ has length $latex d+1$$ and contains the
    120 $th d$$ order Taylor coefficient row vector for $italic X$$.
    121 
    122 
    123 $head z$$
    124 The vector $italic z$$ has length $latex d+1$$ and contains
    125 $th d$$ order Taylor coefficient row vector for $italic z$$.
    126 
    127 $head b$$
    128 The vector $italic b$$ has length $latex d+1$$ and contains
    129 $th d$$ order Taylor coefficient row vector for $italic B$$.
    130 
    131 
    132 $head On Input$$
    133 
    134 $subhead px$$
    135 The vector $italic px$$ has length $latex d+1$$ and
    136 $syntax%%px%[%j%]%$$ contains the partial for $italic G$$
    137 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    138 
    139 $subhead pz$$
    140 The vector $italic pz$$ has length $latex d+1$$ and
    141 $syntax%%pz%[%j%]%$$ contains the partial for $italic G$$
    142 with respect to the $th j$$ order Taylor coefficient for $italic Z$$.
    143 
    144 $subhead pb$$
    145 The vector $italic pb$$ has length $latex d+1$$ and
    146 $syntax%%pb%[%j%]%$$ contains the partial for $italic G$$
    147 with respect to the $th j$$ order Taylor coefficient for $italic B$$.
    148 
    149 $head On Output$$
    150 
    151 $subhead px$$
    152 The vector $italic px$$ has length $latex d+1$$ and
    153 $syntax%%px%[%j%]%$$ contains the partial for $italic H$$
    154 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    155 
    156 $subhead pz$$
    157 The vector $italic ps$$ has length $latex d+1$$ and
    158 its contents are no longer specified; i.e., it has
    159 been used for work space.
    160 
    161 $subhead pb$$
    162 The vector $italic pb$$ has length $latex d+1$$ and
    163 its contents are no longer specified; i.e., it has
    164 been used for work space.
    165 
    166 $end
    167 ------------------------------------------------------------------------------
    168 */
    169 
    170 // BEGIN CppAD namespace
    171 namespace CppAD {
    172 
    173 template <class Base>
    174 inline void ForAtanOp(size_t j,
    175         Base *z, Base *b, const Base *x)
    176 {       size_t k;
    177 
     59        size_t k;
    17860        if( j == 0 )
    17961        {       z[j] = atan( x[0] );
     
    19476}
    19577
     78/*!
     79Zero order forward mode Taylor coefficient for result of op = AtanOp.
     80
     81The C++ source code corresponding to this operation is
     82\verbatim
     83        z = atan(x)
     84\endverbatim
     85The auxillary result is
     86\verbatim
     87        y = 1 + x * x
     88\endverbatim
     89The value of y is computed along with the value of z.
     90
     91\copydetails forward_unary2_op_0
     92*/
    19693template <class Base>
    197 inline void RevAtanOp(size_t d,
    198         const Base  *z, const Base  *b, const Base *x,
    199               Base *pz,       Base *pb,       Base *px)
    200 {       size_t k;
     94inline void forward_atan_op_0(
     95        size_t i_z         ,
     96        size_t i_x         ,
     97        size_t nc_taylor   ,
     98        Base*  taylor      )
     99{
     100        // check assumptions
     101        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
     102        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
     103        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     104        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     105
     106        // Taylor coefficients corresponding to argument and result
     107        Base* x = taylor + i_x * nc_taylor;
     108        Base* z = taylor + i_z * nc_taylor;
     109        Base* b = z      +       nc_taylor; // called y in documentation
     110
     111        z[0] = atan( x[0] );
     112        b[0] = Base(1) + x[0] * x[0];
     113}
     114/*!
     115Reverse mode partial derivatives for result of op = AtanOp.
     116
     117The C++ source code corresponding to this operation is
     118\verbatim
     119        z = atan(x)
     120\endverbatim
     121The auxillary result is
     122\verbatim
     123        y = 1 + x * x
     124\endverbatim
     125The value of y is computed along with the value of z.
     126
     127\copydetails reverse_unary2_op
     128*/
     129
     130template <class Base>
     131inline void reverse_atan_op(
     132        size_t      d            ,
     133        size_t      i_z          ,
     134        size_t      i_x          ,
     135        size_t      nc_taylor    ,
     136        const Base* taylor       ,
     137        size_t      nc_partial   ,
     138        Base*       partial      )
     139{
     140        // check assumptions
     141        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
     142        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
     143        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     144        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     145        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     146
     147        // Taylor coefficients and partials corresponding to argument
     148        const Base* x  = taylor  + i_x * nc_taylor;
     149        Base* px       = partial + i_x * nc_partial;
     150
     151        // Taylor coefficients and partials corresponding to first result
     152        const Base* z  = taylor  + i_z * nc_taylor;
     153        Base* pz       = partial + i_z * nc_partial;
     154
     155        // Taylor coefficients and partials corresponding to auxillary result
     156        const Base* b  = z  + nc_taylor; // called y in documentation
     157        Base* pb       = pz + nc_partial;
    201158
    202159        // number of indices to access
    203160        size_t j = d;
    204 
     161        size_t k;
    205162        while(j)
    206163        {       // scale partials w.r.t z[j] and b[j]
     
    225182}
    226183
    227 } // END CppAD namespace
    228 
     184CPPAD_END_NAMESPACE
    229185# endif
  • trunk/cppad/local/compare.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    174174
    175175        CPPAD_ASSERT_UNKNOWN( ind1 > 1 );
    176         CPPAD_ASSERT_UNKNOWN( NumInd(ComOp) == 4 );
    177         CPPAD_ASSERT_UNKNOWN( NumVar(ComOp) == 0 );
     176        CPPAD_ASSERT_UNKNOWN( NumArg(ComOp) == 4 );
     177        CPPAD_ASSERT_UNKNOWN( NumRes(ComOp) == 0 );
    178178
    179179        // put the operator in the tape
    180180        Rec_.PutOp(ComOp);
    181         Rec_.PutInd(ind0, ind1, ind2, ind3);
     181        Rec_.PutArg(ind0, ind1, ind2, ind3);
    182182}
    183183
  • trunk/cppad/local/cond_exp.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    2727        const
    2828        abs
    29         Op
     29        Rel
    3030        bool
    3131        Lt
     
    4343
    4444$head Syntax$$
    45 $syntax%%result% = CondExp%Op%(%left%, %right%, %trueCase%, %falseCase%)%$$
     45$codei%%result% = CondExp%Rel%(%left%, %right%, %exp_if_true%, %exp_if_false%)%$$
    4646
    4747
    4848$head Purpose$$
    4949Record,
    50 as part of an AD of $italic Base$$
     50as part of an AD of $icode Base$$
    5151$xref/glossary/Operation/Sequence/operation sequence/1/$$,
    5252a the conditional result of the form
    53 $syntax%
    54         if( %left% %op% %right% )
    55                 %result% = %trueCase%
    56         else    %result% = %falseCase%
    57 %$$
    58 The notation $italic Op$$ and $italic op$$
     53$codei%
     54        if( %left% %Cop% %right% )
     55                %result% = %exp_if_true%
     56        else    %result% = %exp_if_false%
     57%$$
     58The relational $icode Rel$$ and comparison operator $icode Cop$$
    5959above have the following correspondence:
    6060$table
    61 $italic Op$$
     61$icode Rel$$
    6262        $pre  $$ $cnext $code Lt$$
    6363        $pre  $$ $cnext $code Le$$
     
    6666        $pre  $$ $cnext $code Gt$$
    6767$rnext
    68 $italic op$$
     68$icode Cop$$
    6969        $cnext $code <$$
    7070        $cnext $code <=$$
     
    7373        $cnext $code >$$
    7474$tend
    75 If $italic f$$ is the $xref/ADFun/$$ object corresponding to the
     75If $icode f$$ is the $xref/ADFun/$$ object corresponding to the
    7676AD operation sequence,
    77 the choice in an AD conditional expression is made each time
     77the assignment choice for $icode result$$
     78in an AD conditional expression is made each time
    7879$xref/Forward//f.Forward/$$ is used to evaluate the zero order Taylor
    7980coefficients with new values for the
     
    8283which are boolean valued and not included in the AD operation sequence.
    8384
    84 $head Op$$
    85 In the syntax above, $italic Op$$ represents one of the following
     85$head Rel$$
     86In the syntax above, the relation $icode Rel$$ represents one of the following
    8687two characters: $code Lt$$, $code Le$$, $code Eq$$, $code Ge$$, $code Gt$$.
    8788As in the table above,
    88 $italic Op$$ determines the comparison operator $italic op$$.
     89$icode Rel$$ determines which comparison operator $icode Cop$$ is used
     90when comparing $icode left$$ and $icode right$$.
    8991
    9092$head Type$$
    9193These functions are defined in the CppAD namespace for arguments of
    92 $italic Type$$ is $code float$$ , $code double$$, or any type of the form
    93 $syntax%AD<%Base%>%$$.
     94$icode Type$$ is $code float$$ , $code double$$, or any type of the form
     95$codei%AD<%Base%>%$$.
    9496(Note that all four arguments must have the same type.)
    9597 
    9698$head left$$
    97 The argument $italic left$$ has prototype
    98 $syntax%
     99The argument $icode left$$ has prototype
     100$codei%
    99101        const %Type% &%left%
    100102%$$
     
    102104 
    103105$head right$$
    104 The argument $italic right$$ has prototype
    105 $syntax%
     106The argument $icode right$$ has prototype
     107$codei%
    106108        const %Type% &%right%
    107109%$$
    108110It specifies the value for the right side of the comparison operator.
    109111
    110 $head trueCase$$
    111 The argument $italic trueCase$$ has prototype
    112 $syntax%
    113         const %Type% &%trueCase%
     112$head exp_if_true$$
     113The argument $icode exp_if_true$$ has prototype
     114$codei%
     115        const %Type% &%exp_if_true%
    114116%$$
    115117It specifies the return value if the result of the comparison is true.
    116118
    117 $head falseCase$$
    118 The argument $italic falseCase$$ has prototype
    119 $syntax%
    120         const %Type% &%falseCase%
     119$head exp_if_false$$
     120The argument $icode exp_if_false$$ has prototype
     121$codei%
     122        const %Type% &%exp_if_false%
    121123%$$
    122124It specifies the return value if the result of the comparison is false.
    123125
    124126$head result$$
    125 The $italic result$$ has prototype
    126 $syntax%
    127         %Type% &%falseCase%
     127The $icode result$$ has prototype
     128$codei%
     129        %Type% &%exp_if_false%
    128130%$$
    129131
     
    131133$head CondExp$$
    132134Previous versions of CppAD used
    133 $syntax%
    134         CondExp(%flag%, %trueCase%, %falseCase%)
     135$codei%
     136        CondExp(%flag%, %exp_if_true%, %exp_if_false%)
    135137%$$
    136138for the same meaning as
    137 $syntax%
    138         CondExpGt(%flag%, %Type%(0), %trueCase%, %falseCase%)
     139$codei%
     140        CondExpGt(%flag%, %Type%(0), %exp_if_true%, %exp_if_false%)
    139141%$$
    140142Use of $code CondExp$$ is deprecated, but continues to be supported.
    141143
    142144$head Operation Sequence$$
    143 This is an AD of $italic Base$$
     145This is an AD of $icode Base$$
    144146$xref/glossary/Operation/Atomic/atomic operation/1/$$
    145147and hence is part of the current
    146 AD of $italic Base$$
     148AD of $icode Base$$
    147149$xref/glossary/Operation/Sequence/operation sequence/1/$$.
    148150
     
    174176namespace CppAD {
    175177
    176 // ------------ CondExpOp(cop, left, right, trueCase, falseCase) --------------
     178// ------------ CondExpOp(cop, left, right, exp_if_true, exp_if_false) --------------
    177179// CompareType and ResultType are different for the forward and reverse
    178180// sparese calculations.
     
    182184        const CompareType        &left ,
    183185        const CompareType       &right ,
    184         const ResultType     &trueCase ,
    185         const ResultType    &falseCase )
     186        const ResultType     &exp_if_true ,
     187        const ResultType    &exp_if_false )
    186188{       ResultType returnValue;
    187189        switch( cop )
     
    189191                case CompareLt:
    190192                if( left < right )
    191                         returnValue = trueCase;
    192                 else    returnValue = falseCase;
     193                        returnValue = exp_if_true;
     194                else    returnValue = exp_if_false;
    193195                break;
    194196
    195197                case CompareLe:
    196198                if( left <= right )
    197                         returnValue = trueCase;
    198                 else    returnValue = falseCase;
     199                        returnValue = exp_if_true;
     200                else    returnValue = exp_if_false;
    199201                break;
    200202
    201203                case CompareEq:
    202204                if( left == right )
    203                         returnValue = trueCase;
    204                 else    returnValue = falseCase;
     205                        returnValue = exp_if_true;
     206                else    returnValue = exp_if_false;
    205207                break;
    206208
    207209                case CompareGe:
    208210                if( left >= right )
    209                         returnValue = trueCase;
    210                 else    returnValue = falseCase;
     211                        returnValue = exp_if_true;
     212                else    returnValue = exp_if_false;
    211213                break;
    212214
    213215                case CompareGt:
    214216                if( left > right )
    215                         returnValue = trueCase;
    216                 else    returnValue = falseCase;
     217                        returnValue = exp_if_true;
     218                else    returnValue = exp_if_false;
    217219                break;
    218220
    219221                default:
    220222                CPPAD_ASSERT_UNKNOWN(0);
    221                 returnValue = trueCase;
     223                returnValue = exp_if_true;
    222224        }
    223225        return returnValue;
     
    228230        const float      &left ,
    229231        const float     &right ,
    230         const float  &trueCase ,
    231         const float &falseCase )
    232 {       return CondExpTemplate(cop, left, right, trueCase, falseCase);
     232        const float  &exp_if_true ,
     233        const float &exp_if_false )
     234{       return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
    233235}
    234236
     
    237239        const double      &left ,
    238240        const double     &right ,
    239         const double  &trueCase ,
    240         const double &falseCase )
    241 {       return CondExpTemplate(cop, left, right, trueCase, falseCase);
     241        const double  &exp_if_true ,
     242        const double &exp_if_false )
     243{       return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
    242244}
    243245
     
    247249        const AD<Base> &left      ,
    248250        const AD<Base> &right     ,
    249         const AD<Base> &trueCase  ,
    250         const AD<Base> &falseCase )
     251        const AD<Base> &exp_if_true  ,
     252        const AD<Base> &exp_if_false )
    251253{
    252254        AD<Base> returnValue;
     
    259261                        case CompareLt:
    260262                        if( left.value_ < right.value_ )
    261                                 returnValue = trueCase;
    262                         else    returnValue = falseCase;
     263                                returnValue = exp_if_true;
     264                        else    returnValue = exp_if_false;
    263265                        break;
    264266
    265267                        case CompareLe:
    266268                        if( left.value_ <= right.value_ )
    267                                 returnValue = trueCase;
    268                         else    returnValue = falseCase;
     269                                returnValue = exp_if_true;
     270                        else    returnValue = exp_if_false;
    269271                        break;
    270272
    271273                        case CompareEq:
    272274                        if( left.value_ == right.value_ )
    273                                 returnValue = trueCase;
    274                         else    returnValue = falseCase;
     275                                returnValue = exp_if_true;
     276                        else    returnValue = exp_if_false;
    275277                        break;
    276278
    277279                        case CompareGe:
    278280                        if( left.value_ >= right.value_ )
    279                                 returnValue = trueCase;
    280                         else    returnValue = falseCase;
     281                                returnValue = exp_if_true;
     282                        else    returnValue = exp_if_false;
    281283                        break;
    282284
    283285                        case CompareGt:
    284286                        if( left.value_ > right.value_ )
    285                                 returnValue = trueCase;
    286                         else    returnValue = falseCase;
     287                                returnValue = exp_if_true;
     288                        else    returnValue = exp_if_false;
    287289                        break;
    288290
    289291                        default:
    290292                        CPPAD_ASSERT_UNKNOWN(0);
    291                         returnValue = trueCase;
     293                        returnValue = exp_if_true;
    292294                }
    293295                return returnValue;
     
    296298        // must use CondExp incase Base is an AD type and recording
    297299        returnValue.value_ = CondExpOp(cop,
    298                 left.value_, right.value_, trueCase.value_, falseCase.value_);
     300                left.value_, right.value_, exp_if_true.value_, exp_if_false.value_);
    299301
    300302        ADTape<Base> *tape = CPPAD_NULL;
     
    303305        if( Variable(right) )
    304306                tape = right.tape_this();
    305         if( Variable(trueCase) )
    306                 tape = trueCase.tape_this();
    307         if( Variable(falseCase) )
    308                 tape = falseCase.tape_this();
     307        if( Variable(exp_if_true) )
     308                tape = exp_if_true.tape_this();
     309        if( Variable(exp_if_false) )
     310                tape = exp_if_false.tape_this();
    309311
    310312        // add this operation to the tape
    311313        if( tape != CPPAD_NULL )
    312314                tape->RecordCondExp(cop,
    313                         returnValue, left, right, trueCase, falseCase);
     315                        returnValue, left, right, exp_if_true, exp_if_false);
    314316
    315317        return returnValue;
    316318}
    317319
    318 // --- RecordCondExp(cop, returnValue, left, right, trueCase, falseCase) -----
     320// --- RecordCondExp(cop, returnValue, left, right, exp_if_true, exp_if_false) -----
    319321
    320322template <class Base>
     
    324326        const AD<Base> &left        ,
    325327        const AD<Base> &right       ,
    326         const AD<Base> &trueCase    ,
    327         const AD<Base> &falseCase   )
     328        const AD<Base> &exp_if_true    ,
     329        const AD<Base> &exp_if_false   )
    328330{       size_t   ind0, ind1, ind2, ind3, ind4, ind5;
    329331        size_t   returnValue_taddr;
    330332
    331333        // taddr_ of this variable
    332         CPPAD_ASSERT_UNKNOWN( NumVar(CExpOp) == 1 );
     334        CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
    333335        returnValue_taddr = Rec_.PutOp(CExpOp);
    334336
     
    337339
    338340        // ind[1] = base 2 representaion of the value
    339         // [Var(left), Var(right), Var(trueCase), Var(falseCase)]
     341        // [Var(left), Var(right), Var(exp_if_true), Var(exp_if_false)]
    340342        ind1 = 0;
    341343
     
    361363        }
    362364
    363         // ind[4] = trueCase address
    364         if( Parameter(trueCase) )
    365                 ind4 = Rec_.PutPar(trueCase.value_);
     365        // ind[4] = exp_if_true address
     366        if( Parameter(exp_if_true) )
     367                ind4 = Rec_.PutPar(exp_if_true.value_);
    366368        else
    367369        {       ind1 += 4;
    368                 ind4 = trueCase.taddr_;
    369         }
    370 
    371         // ind[5] =  falseCase address
    372         if( Parameter(falseCase) )
    373                 ind5 = Rec_.PutPar(falseCase.value_);
     370                ind4 = exp_if_true.taddr_;     
     371        }
     372
     373        // ind[5] =  exp_if_false address
     374        if( Parameter(exp_if_false) )
     375                ind5 = Rec_.PutPar(exp_if_false.value_);
    374376        else
    375377        {       ind1 += 8;
    376                 ind5 = falseCase.taddr_;       
    377         }
    378 
    379         CPPAD_ASSERT_UNKNOWN( NumInd(CExpOp) == 6 );
     378                ind5 = exp_if_false.taddr_;     
     379        }
     380
     381        CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
    380382        CPPAD_ASSERT_UNKNOWN( ind1 > 0 );
    381         Rec_.PutInd(ind0, ind1, ind2, ind3, ind4, ind5);
     383        Rec_.PutArg(ind0, ind1, ind2, ind3, ind4, ind5);
    382384
    383385        // check that returnValue is a dependent variable
     
    385387}
    386388
    387 // ------------ CondExpOp(left, right, trueCase, falseCase) ----------------
     389// ------------ CondExpOp(left, right, exp_if_true, exp_if_false) ----------------
    388390
    389391# define CPPAD_COND_EXP(Name)                                              \
     
    392394                const AD<Base> &left      ,                                \
    393395                const AD<Base> &right     ,                                \
    394                 const AD<Base> &trueCase  ,                                \
    395                 const AD<Base> &falseCase )                                \
     396                const AD<Base> &exp_if_true  ,                                \
     397                const AD<Base> &exp_if_false )                                \
    396398        {                                                                  \
    397399                return CondExpOp(Compare##Name,                            \
    398                         left, right, trueCase, falseCase);                 \
     400                        left, right, exp_if_true, exp_if_false);                 \
    399401        }
    400402
     
    408410CPPAD_INLINE AD<Base> CondExp(
    409411        const AD<Base> &flag      ,
    410         const AD<Base> &trueCase  ,
    411         const AD<Base> &falseCase )
     412        const AD<Base> &exp_if_true  ,
     413        const AD<Base> &exp_if_false )
    412414{       
    413         return CondExpOp(CompareGt, flag, AD<Base>(0), trueCase, falseCase);
     415        return CondExpOp(CompareGt, flag, AD<Base>(0), exp_if_true, exp_if_false);
    414416}
    415417
     
    419421                const Type &left      ,                             \
    420422                const Type &right     ,                             \
    421                 const Type &trueCase  ,                             \
    422                 const Type &falseCase )                             \
     423                const Type &exp_if_true  ,                             \
     424                const Type &exp_if_false )                             \
    423425        {       Type returnValue;                                   \
    424426                if( left Op right )                                 \
    425                         returnValue = trueCase;                     \
    426                 else    returnValue = falseCase;                    \
     427                        returnValue = exp_if_true;                     \
     428                else    returnValue = exp_if_false;                    \
    427429                return returnValue;                                 \
    428430        }
     
    436438inline float CondExp(
    437439        const float &flag      ,
    438         const float &trueCase  ,
    439         const float &falseCase )
     440        const float &exp_if_true  ,
     441        const float &exp_if_false )
    440442{       
    441         return CondExpGt(flag, float(0), trueCase, falseCase);
     443        return CondExpGt(flag, float(0), exp_if_true, exp_if_false);
    442444}
    443445
     
    450452inline double CondExp(
    451453        const double &flag      ,
    452         const double &trueCase  ,
    453         const double &falseCase )
     454        const double &exp_if_true  ,
     455        const double &exp_if_false )
    454456{       
    455         return CondExpGt(flag, 0., trueCase, falseCase);
     457        return CondExpGt(flag, 0., exp_if_true, exp_if_false);
    456458}
    457459
  • trunk/cppad/local/cppad_assert.hpp

    r1401 r1447  
    1313Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1414-------------------------------------------------------------------------- */
     15
     16/*!
     17\file cppad_assert.hpp
     18Define the CppAD error checking macros (all of which begin with CPPAD_ASSERT_)
     19*/
    1520
    1621/*
     
    9196# include <cppad/error_handler.hpp>
    9297
     98
     99/*!
     100\def CPPAD_ASSERT_KNOWN(exp, msg)
     101Check that \a exp is true, if not print \a msg and terminate execution.
     102
     103The C++ expression \a exp is expected to be true.
     104If it is false,
     105the CppAD use has made an error that is described by \a msg.
     106If the preprocessor symbol \a NDEBUG is not defined,
     107and \a exp is false,
     108this macro will report the source code line number at
     109which this expected result occurred.
     110In addition, it will print the specified error message \a msg.
     111*/
    93112# ifdef NDEBUG
    94113# define CPPAD_ASSERT_KNOWN(exp, msg)  // do nothing
     
    105124# endif
    106125
     126/*!
     127\def CPPAD_ASSERT_UNKNOWN(exp)
     128Check that \a exp is true, if not terminate execution.
     129
     130The C++ expression \a exp is expected to be true.
     131If it is false,
     132CppAD has detected an error but does not know the cause of the error.
     133If the preprocessor symbol \a NDEBUG is not defined,
     134and \a exp is false,
     135this macro will report the source code line number at
     136which this expected result occurred.
     137*/
    107138# ifdef NDEBUG
    108139# define CPPAD_ASSERT_UNKNOWN(exp)      // do nothing
     
    119150# endif
    120151
     152/*!
     153\def CPPAD_ASSERT_NARG_NRES(op, n_arg, n_res)
     154Check that operator \a op has the specified number of of arguments and results.
     155
     156If \a NDEBUG is not defined and either the number of arguments
     157or the number of results are not as expected,
     158execution is terminated and the source code line number is reported.
     159*/
     160# define CPPAD_ASSERT_NARG_NRES(op, n_arg, n_res)   \
     161        CPPAD_ASSERT_UNKNOWN( NumArg(op) == n_arg ) \
     162        CPPAD_ASSERT_UNKNOWN( NumRes(op) == n_res )
     163       
     164
    121165# endif
  • trunk/cppad/local/dependent.hpp

    r1401 r1447  
    202202        // make a tape copy of dependent variables that are parameters,
    203203        // and store tape address for each dependent variable
    204         CPPAD_ASSERT_UNKNOWN( NumVar(ParOp) == 1 );
     204        CPPAD_ASSERT_UNKNOWN( NumRes(ParOp) == 1 );
    205205        dep_parameter_.resize(m);
    206206        dep_taddr_.resize(m);
  • trunk/cppad/local/discrete.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    178178                if( Variable(x) )
    179179                {       ADTape<Base> *tape = x.tape_this();
    180                         CPPAD_ASSERT_UNKNOWN( NumVar(DisOp) == 1 );
    181                         CPPAD_ASSERT_UNKNOWN( NumInd(DisOp) == 2 );
     180                        CPPAD_ASSERT_UNKNOWN( NumRes(DisOp) == 1 );
     181                        CPPAD_ASSERT_UNKNOWN( NumArg(DisOp) == 2 );
    182182
    183183                        // put operand addresses in the tape
    184                         tape->Rec_.PutInd(x.taddr_, f_index_);
     184                        tape->Rec_.PutArg(x.taddr_, f_index_);
    185185                        // put operator in the tape
    186186                        result.taddr_ = tape->Rec_.PutOp(DisOp);
  • trunk/cppad/local/div.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5656                                " variables on different tapes."
    5757                        );
    58                         CPPAD_ASSERT_UNKNOWN( NumVar(DivvvOp) == 1 );
    59                         CPPAD_ASSERT_UNKNOWN( NumInd(DivvvOp) == 2 );
     58                        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
     59                        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
    6060
    6161                        // put operand addresses in tape
    62                         tape->Rec_.PutInd(left.taddr_, right.taddr_);
     62                        tape->Rec_.PutArg(left.taddr_, right.taddr_);
    6363                        // put operator in the tape
    6464                        result.taddr_ = tape->Rec_.PutOp(DivvvOp);
     
    7272                else
    7373                {       // result = variable / parameter
    74                         CPPAD_ASSERT_UNKNOWN( NumVar(DivvpOp) == 1 );
    75                         CPPAD_ASSERT_UNKNOWN( NumInd(DivvpOp) == 2 );
     74                        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
     75                        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
    7676
    7777                        // put operand addresses in tape
    7878                        size_t p = tape->Rec_.PutPar(right.value_);
    79                         tape->Rec_.PutInd(left.taddr_, p);
     79                        tape->Rec_.PutArg(left.taddr_, p);
    8080                        // put operator in the tape
    8181                        result.taddr_ = tape->Rec_.PutOp(DivvpOp);
     
    9090                else
    9191                {       // result = parameter / variable
    92                         CPPAD_ASSERT_UNKNOWN( NumVar(DivpvOp) == 1 );
    93                         CPPAD_ASSERT_UNKNOWN( NumInd(DivpvOp) == 2 );
     92                        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
     93                        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
    9494
    9595                        // put operand addresses in tape
    9696                        size_t p = tape->Rec_.PutPar(left.value_);
    97                         tape->Rec_.PutInd(p, right.taddr_);
     97                        tape->Rec_.PutArg(p, right.taddr_);
    9898                        // put operator in the tape
    9999                        result.taddr_ = tape->Rec_.PutOp(DivpvOp);
  • trunk/cppad/local/div_eq.hpp

    r1369 r1447  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5050        {       if( var_right )
    5151                {       // this = variable / variable
    52                         CPPAD_ASSERT_UNKNOWN( NumVar(DivvvOp) == 1 );
    53                         CPPAD_ASSERT_UNKNOWN( NumInd(DivvvOp) == 2 );
     52                        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
     53                        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
    5454
    5555                        // put operand addresses in tape
    56                         tape->Rec_.PutInd(taddr_, right.taddr_);
     56                        tape->Rec_.PutArg(taddr_, right.taddr_);
    5757                        // put operator in the tape
    5858                        taddr_ = tape->Rec_.PutOp(DivvvOp);
     
    6565                else
    6666                {       // this = variable / parameter
    67                         CPPAD_ASSERT_UNKNOWN( NumVar(DivvpOp) == 1 );
    68                         CPPAD_ASSERT_UNKNOWN( NumInd(DivvpOp) == 2 );
     67                        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
     68                        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
    6969
    7070                        // put operand addresses in tape
    7171                        size_t p = tape->Rec_.PutPar(right.value_);
    72                         tape->Rec_.PutInd(taddr_, p);
     72                        tape->Rec_.PutArg(taddr_, p);
    7373                        // put operator in the tape
    7474                        taddr_ = tape->Rec_.PutOp(DivvpOp);
     
    8383                else
    8484                {       // this = parameter / variable
    85                         CPPAD_ASSERT_UNKNOWN( NumVar(DivpvOp) == 1 );
    86                         CPPAD_ASSERT_UNKNOWN( NumInd(DivpvOp) == 2 );
     85                        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
     86                        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
    8787
    8888                        // put operand addresses in tape
    8989                        size_t p = tape->Rec_.PutPar(left);
    90                         tape->Rec_.PutInd(p, right.taddr_);
     90                        tape->Rec_.PutArg(p, right.taddr_);
    9191                        // put operator in the tape
    9292                        taddr_ = tape->Rec_.PutOp(DivpvOp);
  • trunk/cppad/local/div_op.hpp

    r1369 r1447  
    22# ifndef CPPAD_DIV_OP_INCLUDED
    33# define CPPAD_DIV_OP_INCLUDED
     4CPPAD_BEGIN_NAMESPACE
    45
    56/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     7CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    78
    89CppAD is distributed under multiple licenses. This distribution is under
     
    1415-------------------------------------------------------------------------- */
    1516
    16 /*
    17 $begin ForDivvvOp$$ $comment CppAD Developer Documentation$$
    18 $spell
    19         Div
    20         Divpv
    21         Divvp
    22         Divvv
    23         Taylor
    24         const
    25         inline
    26         Op
    27 $$
    28 
    29 $index divide, forward operator$$
    30 $index forward, divide operator$$
    31 $index operator, divide forward$$
    32 $index ForDiv$$
    33 
    34 $section Forward Mode Division Operator$$
    35 
    36 $head Syntax$$
    37 
    38 $syntax%inline void ForDivvvOp(size_t %d%,
    39         %Base% *%z%, const %Base% *%x%, const %Base% *%y%)%$$
    40 $pre
    41 $$
    42 $syntax%inline void ForDivpvOp(size_t %d%,
    43         %Base% *%z%, const %Base% *%p%, const %Base% *%y%)%$$
    44 $pre
    45 $$
    46 $syntax%inline void ForDivvpOp(size_t %d%,
    47         %Base% *%z%, const %Base% *%x%, const %Base% *%p%)%$$
    48 
    49 
    50 $head Description$$
    51 Computes the $italic d$$ order Taylor coefficient for $latex Z$$ where
    52 $table
    53 Operation  $cnext Value  $rnext
    54 Divvv       $cnext $latex Z = X / Y$$ $rnext
    55 Divpv       $cnext $latex Z = P / Y$$ $rnext
    56 Divvp       $cnext $latex Z = X / P$$
    57 $tend
    58 
    59 $head x$$
    60 The vector $italic x$$ has length $latex d+1$$ and contains the
    61 $th d$$ order Taylor coefficient row vector for $italic X$$.
    62 
    63 $head y$$
    64 The vector $italic y$$ has length $latex d+1$$ and contains the
    65 $th d$$ order Taylor coefficient row vector for $italic Y$$.
    66 
    67 $head p$$
    68 The scalar $syntax%*%p%$$ contains the value of the parameter $italic P$$.
    69 
    70 
    71 $head z$$
    72 The vector $italic z$$ has length $latex d+1$$.
    73 On input it contains the
    74 $th d-1$$ order Taylor coefficient row vector for $italic Z$$.
    75 On output it contains the
    76 $th d$$ order Taylor coefficient row vector for $italic Z$$; i.e.,
    77 $syntax%%z%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    78 the function $italic Z$$.
    79 
    80 $end
    81 ------------------------------------------------------------------------------
    82 $begin RevDivvvOp$$ $comment CppAD Developer Documentation$$
    83 $spell
    84         Div
    85         Divpv
    86         Divvp
    87         Divvv
    88         Taylor
    89         const
    90         inline
    91         Op
    92         px
    93         py
    94         pz
    95 $$
    96 
    97 
    98 $index divide, reverse operator$$
    99 $index reverse, divide operator$$
    100 $index operator, divide reverse$$
    101 $index ForDiv$$
    102 
    103 $section Reverse Mode Division Operator$$
    104 
    105 $head Syntax$$
    106 
    107 $syntax%inline void RevDivvvOp(size_t %d%,
    108         const %Base% *%z%, const %Base% *%x%, const %Base% *%y%,
    109         %Base% *%pz%, %Base% *%px%, %Base% *%py%)%$$
    110 $pre
    111 $$
    112 $syntax%inline void RevDivpvOp(size_t %d%,
    113         const %Base% *%z%, const %Base% *%p%, const %Base% *%y%,
    114         %Base% *%pz%, %Base% *%py%)%$$
    115 $pre
    116 $$
    117 $syntax%inline void RevDivvpOp(size_t %d%,
    118         const %Base% *%z%, const %Base% *%x%, const %Base% *%p%,
    119         const %Base% *%pz%, %Base% *%px%)%$$
    120 
    121 $head Description$$
    122 We are given the partial derivatives for a function
    123 $latex G(z, x, y)$$ and we wish to compute the partial derivatives for
    124 the function
    125 $latex \[
    126         H(x, y) = G [ Z(x, y) , x , y ]
    127 \]$$
    128 where $latex Z(x, y)$$ is defined as the
    129 $th d$$ order Taylor coefficient row vector for $italic Z$$ as
    130 a function of the corresponding vectors for
    131 $italic X$$ and $italic Y$$ where
    132 
    133 $table
    134 Operation  $cnext Value  $rnext
    135 Divvv      $cnext $latex Z = X / Y$$ $rnext
    136 Divvp      $cnext $latex Z = P / Y$$ $rnext
    137 Divpv      $cnext $latex Z = X / P$$
    138 $tend
    139 
    140 Note that $italic Z$$ has been used both the original division
    141 function and for the corresponding mapping of Taylor coefficients.
    142 
    143 $head z$$
    144 The vector $italic z$$ has length $latex d+1$$ and contains the
    145 $th d$$ order Taylor coefficient row vector for $italic Z$$.
    146 
    147 $head x$$
    148 The vector $italic x$$ has length $latex d+1$$ and contains the
    149 $th d$$ order Taylor coefficient row vector for $italic X$$.
    150 
    151 $head y$$
    152 The vector $italic y$$ has length $latex d+1$$ and contains the
    153 $th d$$ order Taylor coefficient row vector for $italic Y$$.
    154 
    155 $head p$$
    156 The scalar $syntax%*%p%$$ contains the value of the parameter $italic P$$.
    157 
    158 
    159 $head On Input$$
    160 
    161 $subhead px$$
    162 The vector $italic px$$ has length $latex d+1$$ and
    163 $syntax%%px%[%j%]%$$ contains the partial for $italic G$$
    164 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    165 
    166 $subhead py$$
    167 The vector $italic py$$ has length $latex d+1$$ and
    168 $syntax%%py%[%j%]%$$ contains the partial for $italic G$$
    169 with respect to the $th j$$ order Taylor coefficient for $italic Y$$.
    170 
    171 $head pz$$
    172 The vector $italic pz$$ has length $latex d+1$$ and
    173 $syntax%%pz%[%j%]%$$ contains the partial for $italic G$$
    174 with respect to the $th j$$ order Taylor coefficient for $italic Z$$.
    175 
    176 $head On Output$$
    177 
    178 $subhead px$$
    179 If present,
    180 the vector $italic px$$ has length $latex d+1$$ and
    181 $syntax%%px%[%j%]%$$ contains the partial for $italic H$$
    182 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    183 
    184 $subhead py$$
    185 If present,
    186 the vector $italic py$$ has length $latex d+1$$ and
    187 $syntax%%py%[%j%]%$$ contains the partial for $italic H$$
    188 with respect to the $th j$$ order Taylor coefficient for $italic Y$$.
    189 
    190 
    191 $subhead pz$$
    192 The vector $italic pz$$ has length $latex d+1$$ and
    193 its contents are no longer specified value; i.e., it has been used
    194 for work space.
    195 
    196 $end
    197 ------------------------------------------------------------------------------
    198 */
    199 
    200 // BEGIN CppAD namespace
    201 namespace CppAD {
     17/*!
     18\file div_op.hpp
     19Forward and reverse mode calculations for z = x / y.
     20*/
    20221
    20322// --------------------------- Divvv -----------------------------------------
    204 
    205 template <class Base>
    206 inline void ForDivvvOp(size_t j,
    207         Base *z, const Base *x, const Base *y)
    208 {
     23/*!
     24Compute forward mode Taylor coefficients for result of op = DivvvOp.
     25
     26The C++ source code corespnding to this operation is
     27\verbatim
     28        z = x / y
     29\endverbatim
     30In the documentation below,
     31this operations is for the case where both x and y are variables
     32and the argument \a parameter is not used.
     33
     34\copydetails forward_binary_op
     35*/
     36
     37template <class Base>
     38inline void forward_divvv_op(
     39        size_t        d           ,
     40        size_t        i_z         ,
     41        const size_t* arg         ,
     42        const Base*   parameter   ,
     43        size_t        nc_taylor   ,
     44        Base*         taylor      )
     45{
     46        // check assumptions
     47        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
     48        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
     49        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     50        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     51        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     52
     53        // Taylor coefficients corresponding to arguments and result
     54        Base* x = taylor + arg[0] * nc_taylor;
     55        Base* y = taylor + arg[1] * nc_taylor;
     56        Base* z = taylor + i_z    * nc_taylor;
     57
     58
     59        // Using CondExp, it can make sense to divide by zero,
     60        // so do not make it an error.
    20961        size_t k;
    210 
    211 # if 0
    212 // 05-01-08 removed divide by zero check for better use of CondExp
    213         CPPAD_ASSERT_KNOWN(
    214                 y[0] != Base(0),
    215                 "Attempt to divide by zero"
    216         );
    217 # endif
    218 
    219         z[j] = x[j];
    220         for(k = 1; k <= j; k++)
    221                 z[j] -= z[j-k] * y[k];
    222         z[j] /= y[0];
    223 }
    224 
    225 template <class Base>
    226 inline void RevDivvvOp(size_t d,
    227         const Base  *z, const Base *x, const Base *y,
    228         Base       *pz, Base      *px, Base      *py)
    229 {       size_t k;
    230 
     62        z[d] = x[d];
     63        for(k = 1; k <= d; k++)
     64                z[d] -= z[d-k] * y[k];
     65        z[d] /= y[0];
     66}
     67
     68
     69/*!
     70Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
     71
     72The C++ source code corespnding to this operation is
     73\verbatim
     74        z = x / y
     75\endverbatim
     76In the documentation below,
     77this operations is for the case where both x and y are variables
     78and the argument \a parameter is not used.
     79
     80\copydetails forward_binary_op_0
     81*/
     82
     83template <class Base>
     84inline void forward_divvv_op_0(
     85        size_t        i_z         ,
     86        const size_t* arg         ,
     87        const Base*   parameter   ,
     88        size_t        nc_taylor   ,
     89        Base*         taylor      )
     90{
     91        // check assumptions
     92        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
     93        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
     94        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     95        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     96
     97        // Taylor coefficients corresponding to arguments and result
     98        Base* x = taylor + arg[0] * nc_taylor;
     99        Base* y = taylor + arg[1] * nc_taylor;
     100        Base* z = taylor + i_z    * nc_taylor;
     101
     102        z[0] = x[0] / y[0];
     103}
     104
     105/*!
     106Compute reverse mode partial derivatives for result of op = DivvvOp.
     107
     108The C++ source code corespnding to this operation is
     109\verbatim
     110        z = x / y
     111\endverbatim
     112In the documentation below,
     113this operations is for the case where both x and y are variables
     114and the argument \a parameter is not used.
     115
     116\copydetails reverse_binary_op
     117*/
     118
     119template <class Base>
     120inline void reverse_divvv_op(
     121        size_t        d           ,
     122        size_t        i_z         ,
     123        const size_t* arg         ,
     124        const Base*   parameter   ,
     125        size_t        nc_taylor   ,
     126        const Base*   taylor      ,
     127        size_t        nc_partial  ,
     128        Base*         partial     )
     129{
     130        // check assumptions
     131        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
     132        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
     133        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     134        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     135        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     136        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     137
     138        // Arguments
     139        const Base* y  = taylor + arg[1] * nc_taylor;
     140        const Base* z  = taylor + i_z    * nc_taylor;
     141
     142        // Partial derivatives corresponding to arguments and result
     143        Base* px = partial + arg[0] * nc_partial;
     144        Base* py = partial + arg[1] * nc_partial;
     145        Base* pz = partial + i_z    * nc_partial;
     146
     147        // Using CondExp, it can make sense to divide by zero
     148        // so do not make it an error.
     149
     150        size_t k;
    231151        // number of indices to access
    232152        size_t j = d + 1;
    233 
    234 # if 0
    235 // 05-01-08 removed divide by zero check for better use of CondExp
    236         CPPAD_ASSERT_KNOWN(
    237                 y[0] != Base(0),
    238                 "Attempt to divide by zero"
    239         );
    240 # endif
    241 
    242153        while(j)
    243154        {       --j;
     
    254165}
    255166
    256 // --------------------------- Divpv ----------------------------------------
    257 
    258 template <class Base>
    259 inline void ForDivpvOp(size_t j,
    260         Base *z, const Base *p, const Base *y)
    261 {       size_t k;
    262 
    263 # if 0
    264 // 05-01-08 removed divide by zero check for better use of CondExp
    265         CPPAD_ASSERT_KNOWN(
    266                 y[0] != Base(0),
    267                 "Attempt to divide by zero"
    268         );
     167// --------------------------- Divpv -----------------------------------------
     168/*!
     169Compute forward mode Taylor coefficients for result of op = DivpvOp.
     170
     171The C++ source code corespnding to this operation is
     172\verbatim
     173        z = x / y
     174\endverbatim
     175In the documentation below,
     176this operations is for the case where x is a parameter and y is a variable.
     177
     178\copydetails forward_binary_op
     179*/
     180
     181template <class Base>
     182inline void forward_divpv_op(
     183        size_t        d           ,
     184        size_t        i_z         ,
     185        const size_t* arg         ,
     186        const Base*   parameter   ,
     187        size_t        nc_taylor   ,
     188        Base*         taylor      )
     189{
     190        // check assumptions
     191        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
     192        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
     193        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     194        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     195
     196        // Taylor coefficients corresponding to arguments and result
     197        Base* y = taylor + arg[1] * nc_taylor;
     198        Base* z = taylor + i_z    * nc_taylor;
     199
     200        // Paraemter value
     201        Base x = parameter[ arg[0] ];
     202
     203        // Using CondExp, it can make sense to divide by zero,
     204        // so do not make it an error.
     205        size_t k;
     206# if USE_CPPAD_FORWARD0SWEEP
     207        z[d] = Base(0);
     208# else
     209        if( d == 0 )
     210                z[d] = x;
     211        else    z[d] = Base(0);
    269212# endif
    270 
    271         if( j == 0 )
    272                 z[j] = (*p);
    273         else    z[j] = Base(0);
    274         for(k = 1; k <= j; k++)
    275                 z[j] -= z[j-k] * y[k];
    276         z[j] /= y[0];
    277 
    278 }
    279 
    280 template <class Base>
    281 inline void RevDivpvOp(size_t d,
    282         const Base  *z, const Base *p, const Base *y,
    283         Base       *pz, Base      *py)
    284 {       size_t k;
    285 
     213        for(k = 1; k <= d; k++)
     214                z[d] -= z[d-k] * y[k];
     215        z[d] /= y[0];
     216
     217}
     218
     219/*!
     220Compute zero order forward mode Taylor coefficient for result of op = DivpvOp.
     221
     222The C++ source code corespnding to this operation is
     223\verbatim
     224        z = x / y
     225\endverbatim
     226In the documentation below,
     227this operations is for the case where x is a parameter and y is a variable.
     228
     229\copydetails forward_binary_op_0
     230*/
     231
     232template <class Base>
     233inline void forward_divpv_op_0(
     234        size_t        i_z         ,
     235        const size_t* arg         ,
     236        const Base*   parameter   ,
     237        size_t        nc_taylor   ,
     238        Base*         taylor      )
     239{
     240        // check assumptions
     241        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
     242        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
     243        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     244
     245        // Paraemter value
     246        Base x = parameter[ arg[0] ];
     247
     248        // Taylor coefficients corresponding to arguments and result
     249        Base* y = taylor + arg[1] * nc_taylor;
     250        Base* z = taylor + i_z    * nc_taylor;
     251
     252        z[0] = x / y[0];
     253}
     254
     255/*!
     256Compute reverse mode partial derivative for result of op = DivpvOp.
     257
     258The C++ source code corespnding to this operation is
     259\verbatim
     260        z = x / y
     261\endverbatim
     262In the documentation below,
     263this operations is for the case where x is a parameter and y is a variable.
     264
     265\copydetails reverse_binary_op
     266*/
     267
     268template <class Base>
     269inline void reverse_divpv_op(
     270        size_t        d           ,
     271        size_t        i_z         ,
     272        const size_t* arg         ,
     273        const Base*   parameter   ,
     274        size_t        nc_taylor   ,
     275        const Base*   taylor      ,
     276        size_t        nc_partial  ,
     277        Base*         partial     )
     278{
     279        // check assumptions
     280        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
     281        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
     282        CPPAD_ASSERT_UNKNOWN( arg[1] < i_z );
     283        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     284        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     285
     286        // Arguments
     287        const Base* y = taylor + arg[1] * nc_taylor;
     288        const Base* z = taylor + i_z    * nc_taylor;
     289
     290        // Partial derivatives corresponding to arguments and result
     291        Base* py = partial + arg[1] * nc_partial;
     292        Base* pz = partial + i_z    * nc_partial;
     293
     294        // Using CondExp, it can make sense to divide by zero so do not
     295        // make it an error.
     296
     297        size_t k;
    286298        // number of indices to access
    287299        size_t j = d + 1;
    288 
    289 # if 0
    290 // 05-01-08 removed divide by zero check for better use of CondExp
    291         CPPAD_ASSERT_KNOWN(
    292                 y[0] != Base(0),
    293                 "Attempt to divide by zero"
    294         );
    295 # endif
    296 
    297300        while(j)
    298301        {       --j;
     
    308311}
    309312
    310 // --------------------------- Divvp ------------------------------------------
    311 
    312 template <class Base>
    313 inline void ForDivvpOp(size_t j,
    314         Base *z, const Base *x, const Base *p)
    315 {
    316         z[j] = x[j] / (*p);
    317 }
    318 
    319 template <class Base>
    320 inline void RevDivvpOp(size_t d,
    321         const Base  *z, const Base *x, const Base *p,
    322         const Base *pz, Base *px)
    323 {
     313
     314// --------------------------- Divvp -----------------------------------------
     315/*!
     316Compute forward mode Taylor coefficients for result of op = DivvvOp.
     317
     318The C++ source code corespnding to this operation is
     319\verbatim
     320        z = x / y
     321\endverbatim
     322In the documentation below,
     323this operations is for the case where x is a variable and y is a parameter.
     324
     325\copydetails forward_binary_op
     326*/
     327
     328template <class Base>
     329inline void forward_divvp_op(
     330        size_t        d           ,
     331        size_t        i_z         ,
     332        const size_t* arg         ,
     333        const Base*   parameter   ,
     334        size_t        nc_taylor   ,
     335        Base*         taylor      )
     336{
     337        // check assumptions
     338        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
     339        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
     340        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     341        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     342
     343        // Taylor coefficients corresponding to arguments and result
     344        Base* x = taylor + arg[0] * nc_taylor;
     345        Base* z = taylor + i_z    * nc_taylor;
     346
     347        // Parameter value
     348        Base y = parameter[ arg[1] ];
     349
     350        // Using CondExp and multiple levels of AD, it can make sense
     351        // to divide by zero so do not make it an error.
     352        z[d] = x[d] / y;
     353}
     354
     355
     356/*!
     357Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
     358
     359The C++ source code corespnding to this operation is
     360\verbatim
     361        z = x / y
     362\endverbatim
     363In the documentation below,
     364this operations is for the case where x is a variable and y is a parameter.
     365
     366\copydetails forward_binary_op_0
     367*/
     368
     369template <class Base>
     370inline void forward_divvp_op_0(
     371        size_t        i_z         ,
     372        const size_t* arg         ,
     373        const Base*   parameter   ,
     374        size_t        nc_taylor   ,
     375        Base*         taylor      )
     376{
     377        // check assumptions
     378        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
     379        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
     380        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     381
     382        // Parameter value
     383        Base y = parameter[ arg[1] ];
     384
     385        // Taylor coefficients corresponding to arguments and result
     386        Base* x = taylor + arg[0] * nc_taylor;
     387        Base* z = taylor + i_z    * nc_taylor;
     388
     389        z[0] = x[0] / y;
     390}
     391
     392/*!
     393Compute reverse mode partial derivative for result of op = DivvpOp.
     394
     395The C++ source code corespnding to this operation is
     396\verbatim
     397        z = x / y
     398\endverbatim
     399In the documentation below,
     400this operations is for the case where x is a variable and y is a parameter.
     401
     402\copydetails reverse_binary_op
     403*/
     404
     405template <class Base>
     406inline void reverse_divvp_op(
     407        size_t        d           ,
     408        size_t        i_z         ,
     409        const size_t* arg         ,
     410        const Base*   parameter   ,
     411        size_t        nc_taylor   ,
     412        const Base*   taylor      ,
     413        size_t        nc_partial  ,
     414        Base*         partial     )
     415{
     416        // check assumptions
     417        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
     418        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
     419        CPPAD_ASSERT_UNKNOWN( arg[0] < i_z );
     420        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     421        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     422
     423        // Argument values
     424        Base  y = parameter[ arg[1] ];
     425
     426        // Partial derivatives corresponding to arguments and result
     427        Base* px = partial + arg[0] * nc_partial;
     428        Base* pz = partial + i_z    * nc_partial;
     429
     430        // Using CondExp, it can make sense to divide by zero
     431        // so do not make it an error.
     432
    324433        // number of indices to access
    325434        size_t j = d + 1;
    326 
    327 # if 0
    328 // 05-01-08 removed divide by zero check for better use of CondExp
    329         // should catch this case in zero order forward mode
    330         CPPAD_ASSERT_UNKNOWN( (*p) != Base(0) );
    331 # endif
    332 
    333435        while(j)
    334436        {       --j;
    335                 px[j] += pz[j] / (*p);
     437                px[j] += pz[j] / y;
    336438        }
    337439}
    338440
    339 } // END CppAD namespace
    340 
     441CPPAD_END_NAMESPACE
    341442# endif
  • trunk/cppad/local/exp_op.hpp

    r1369 r1447  
    22# ifndef CPPAD_EXP_OP_INCLUDED
    33# define CPPAD_EXP_OP_INCLUDED
     4CPPAD_BEGIN_NAMESPACE
    45
    56/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     7CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    78
    89CppAD is distributed under multiple licenses. This distribution is under
     
    1415-------------------------------------------------------------------------- */
    1516
    16 /*
    17 $begin ForExpOp$$ $comment CppAD Developer Documentation$$
    18 $spell
    19         Exp
    20         Taylor
    21         const
    22         inline
    23         Op
    24 $$
    2517
    26 $index forward, exp$$
    27 $index exp, forward$$
    28 $index ForExpOp$$
    29 
    30 $section Forward Mode Exponential Function$$
    31 
    32 $head Syntax$$
    33 
    34 $syntax%inline void ForExpOp(size_t %d%,
    35         %Base% *%z%, const %Base% *%x%)%$$
    36 
    37 $head Description$$
    38 Computes the $italic d$$ order Taylor coefficient for $latex Z$$ where
    39 $syntax%
    40         %Z% = Exp(%X%)
    41 %$$
    42 
    43 $head x$$
    44 The vector $italic x$$ has length $latex d+1$$ and contains the
    45 $th d$$ order Taylor coefficient row vector for $italic X$$.
    46 
    47 $head z$$
    48 The vector $italic z$$ has length $latex d+1$$.
    49 On input it contains the
    50 $th d-1$$ order Taylor coefficient row vector for $italic Z$$.
    51 On output it contains the
    52 $th d$$ order Taylor coefficient row vector for $italic Z$$; i.e.,
    53 $syntax%%z%[%d%]%$$ is set equal to the $th d$$ Taylor coefficient for
    54 the function $italic Z$$.
    55 
    56 $end
    57 ------------------------------------------------------------------------------
    58 $begin RevExpOp$$ $comment CppAD Developer Documentation$$
    59 $spell
    60         Exp
    61         Taylor
    62         const
    63         inline
    64         Op
    65         px
    66         py
    67         pz
    68 $$
    69 
    70 $index reverse, exp$$
    71 $index exp, reverse$$
    72 $index RevExpOp$$
    73 
    74 $section Reverse Mode Exponential Function$$
    75 
    76 $head Syntax$$
    77 
    78 $syntax%inline void RevExpOp(size_t %d%,
    79         const %Base% *%z%, const %Base% *%x%,
    80          %Base% *%pz%, %Base% *%px%)%$$
    81 
    82 $head Description$$
    83 We are given the partial derivatives for a function
    84 $latex G(z, x)$$ and we wish to compute the partial derivatives for
    85 the function
    86 $latex \[
    87         H(x) = G [ Z(x) , x ]
    88 \]$$
    89 where $latex Z(x)$$ is defined as the
    90 $th d$$ order Taylor coefficient row vector for $italic Z$$ as
    91 a function of the corresponding row vector for $italic X$$
    92 and
    93 $latex \[
    94         Z = Exp(X)
    95 \]$$
    96 Note that $italic Z$$ has been used both the original exponential
    97 function and for the corresponding mapping of Taylor coefficients.
    98 
    99 $head x$$
    100 The vector $italic x$$ has length $latex d+1$$ and contains the
    101 $th d$$ order Taylor coefficient row vector for $italic X$$.
     18/*!
     19\file exp_op.hpp
     20Forward and reverse mode calculations for z = exp(x).
     21*/
    10222
    10323
    104 $head z$$
    105 The vector $italic z$$ has length $latex d+1$$ and contains
    106 $th d$$ order Taylor coefficient row vector for $italic Z$$.
     24/*!
     25Forward mode Taylor coefficient for result of op = ExpOp.
    10726
     27The C++ source code corresponding to this operation is
     28\verbatim
     29        z = exp(x)
     30\endverbatim
    10831
    109 $head On Input$$
     32\copydetails forward_unary1_op
     33*/
     34template <class Base>
     35inline void forward_exp_op(
     36        size_t j           ,
     37        size_t i_z         ,
     38        size_t i_x         ,
     39        size_t nc_taylor   ,
     40        Base*  taylor      )
     41{       
     42        // check assumptions
     43        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
     44        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
     45        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     46        CPPAD_ASSERT_UNKNOWN( j < nc_taylor );
    11047
    111 $subhead px$$
    112 The vector $italic px$$ has length $latex d+1$$ and
    113 $syntax%%px%[%j%]%$$ contains the partial for $italic G$$
    114 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
     48        // Taylor coefficients corresponding to argument and result
     49        Base* x = taylor + i_x * nc_taylor;
     50        Base* z = taylor + i_z * nc_taylor;
    11551
    116 $subhead pz$$
    117 The vector $italic pz$$ has length $latex d+1$$ and
    118 $syntax%%pz%[%j%]%$$ contains the partial for $italic G$$
    119 with respect to the $th j$$ order Taylor coefficient for $italic Y$$.
    120 
    121 $head On Output$$
    122 
    123 $subhead px$$
    124 The vector $italic px$$ has length $latex d+1$$ and
    125 $syntax%%px%[%j%]%$$ contains the partial for $italic H$$
    126 with respect to the $th j$$ order Taylor coefficient for $italic X$$.
    127 
    128 $subhead pz$$
    129 The vector $italic pz$$ has length $latex d+1$$ and
    130 its contents are no longer specified; i.e., it has
    131 been used for work space.
    132 
    133 $end
    134 ------------------------------------------------------------------------------
    135 */
    136 
    137 // BEGIN CppAD namespace
    138 namespace CppAD {
    139 
    140 template <class Base>
    141 inline void ForExpOp(size_t j,
    142         Base *z, const Base *x)
    143 {       size_t k;
    144 
     52        size_t k;
    14553        if( j == 0 )
    146                 z[j] = exp( x[0] );
     54                z[0] = exp( x[0] );
    14755        else
    14856        {
    149                 z[j] = Base(0);
    150                 for(k = 1; k <= j; k++)
     57                z[j] = x[1] * z[j-1];
     58                for(k = 2; k <= j; k++)
    15159                        z[j] += Base(k) * x[k] * z[j-k];
    15260                z[j] /= Base(j);
     
    15462}
    15563
     64/*!
     65Zero order forward mode Taylor coefficient for result of op = ExpOp.
     66
     67The C++ source code corresponding to this operation is
     68\verbatim
     69        z = exp(x)
     70\endverbatim
     71
     72\copydetails forward_unary1_op_0
     73*/
    15674template <class Base>
    157 inline void RevExpOp(size_t d,
    158         const Base  *z, const Base *x,
    159               Base *pz,      Base *px)
    160 {       size_t k;
     75inline void forward_exp_op_0(
     76        size_t i_z         ,
     77        size_t i_x         ,
     78        size_t nc_taylor   ,
     79        Base*  taylor      )
     80{
     81        // check assumptions
     82        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
     83        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
     84        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     85        CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
    16186
    162         // number of indices to access
    163         size_t j = d;
     87        // Taylor coefficients corresponding to argument and result
     88        Base* x = taylor + i_x * nc_taylor;
     89        Base* z = taylor + i_z * nc_taylor;
    16490
     91        z[0] = exp( x[0] );
     92}
     93/*!
     94Reverse mode partial derivatives for result of op = ExpOp.
     95
     96The C++ source code corresponding to this operation is
     97\verbatim
     98        z = exp(x)
     99\endverbatim
     100
     101\copydetails reverse_unary1_op
     102*/
     103
     104template <class Base>
     105inline void reverse_exp_op(
     106        size_t      d            ,
     107        size_t      i_z          ,
     108        size_t      i_x          ,
     109        size_t      nc_taylor    ,
     110        const Base* taylor       ,
     111        size_t      nc_partial   ,
     112        Base*       partial      )
     113{
     114        // check assumptions
     115        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
     116        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
     117        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     118        CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     119        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
     120
     121        // Taylor coefficients and partials corresponding to argument
     122        const Base* x  = taylor  + i_x * nc_taylor;
     123        Base* px       = partial + i_x * nc_partial;
     124
     125        // Taylor coefficients and partials corresponding to result
     126        const Base* z  = taylor  + i_z * nc_taylor;
     127        Base* pz       = partial + i_z * nc_partial;
     128
     129        // lopp through orders in reverse
     130        size_t j, k;
     131        j = d;
    165132        while(j)
    166133        {       // scale partial w.r.t z[j]
     
    176143}
    177144
    178 } // END CppAD namespace
    179 
     145CPPAD_END_NAMESPACE
    180146# endif
  • trunk/cppad/local/for_jac_sweep.hpp

    r1401 r1447  
    151151        size_t         i_op;
    152152        size_t        i_var;
    153         size_t        n_ind;
    154         size_t        n_var = 0; // assign to avoid warning
    155 
    156         const size_t   *ind = 0;
    157         const size_t *ind_0 = 0;
     153
     154        const size_t   *arg = 0;
     155        const size_t *arg_0 = 0;
    158156        const Pack       *X = 0;
    159157        const Pack       *Y = 0;
    160158
    161159        Pack             *Z = 0;
    162         Pack           *Tmp = 0;
    163160
    164161        size_t            j;
     
    180177
    181178        // skip the NonOp at the beginning of the recording
    182         Rec->start_forward(op, ind, i_op, i_var);
    183         ind_0 = ind;
     179        Rec->start_forward(op, arg, i_op, i_var);
     180        arg_0 = arg;
    184181        while(i_op < numop_m1)
    185182        {
    186183                // this op
    187                 Rec->next_forward(op, ind, i_op, i_var);
    188 
    189                 // number of variables
    190                 n_var  = NumVar(op);
    191 
    192                 // index field values for this op
    193                 n_ind  = NumInd(op);
     184                Rec->next_forward(op, arg, i_op, i_var);
    194185
    195186                // value of z for this op
     
    200191                {
    201192                        case AbsOp:
    202                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    203                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    204                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    205                         X   = ForJac + ind[0] * npv;
    206                         for(j = 0; j < npv; j++)
    207                                 Z[j] = X[j];
     193                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     194                        forward_sparse_jacobian_unary_op(
     195                                i_var, arg[0], npv, ForJac
     196                        );
    208197                        break;
    209198                        // -------------------------------------------------
    210199
    211200                        case AddvvOp:
    212                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    213                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    214                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    215                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    216 
    217                         X = ForJac + ind[0] * npv;
    218                         Y = ForJac + ind[1] * npv;
     201                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     202                        CPPAD_ASSERT_UNKNOWN( arg[0] < i_var );
     203                        CPPAD_ASSERT_UNKNOWN( arg[1] < i_var );
     204
     205                        X = ForJac + arg[0] * npv;
     206                        Y = ForJac + arg[1] * npv;
    219207                        for(j = 0; j < npv; j++)
    220208                                Z[j] = X[j] | Y[j];
     
    223211
    224212                        case AddpvOp:
    225                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    226                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    227                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    228 
    229                         Y = ForJac + ind[1] * npv;
    230                         for(j = 0; j < npv; j++)
    231                                 Z[j] = Y[j];
     213                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     214                        forward_sparse_jacobian_unary_op(
     215                                i_var, arg[1], npv, ForJac
     216                        );
    232217                        break;
    233218                        // -------------------------------------------------
    234219
    235220                        case AddvpOp:
    236                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    237                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    238                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    239 
    240                         X = ForJac + ind[0] * npv;
    241                         for(j = 0; j < npv; j++)
    242                                 Z[j] = X[j];
     221                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     222                        forward_sparse_jacobian_unary_op(
     223                                i_var, arg[0], npv, ForJac
     224                        );
    243225                        break;
    244226                        // -------------------------------------------------
    245227
    246228                        case AcosOp:
    247                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    248                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    249 
    250229                        // acos(x) and sqrt(1 - x * x) are computed in pairs
    251                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
    252                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    253 
    254                         // use Tmp for data stored in variable record
    255                         Tmp = ForJac + (i_var+1) * npv;
    256                         X   = ForJac + ind[0] * npv;
    257                         for(j = 0; j < npv; j++)
    258                                 Tmp[j] = Z[j] = X[j];
     230                        // but ivar + 1 should only be used here
     231                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     232                        forward_sparse_jacobian_unary_op(
     233                                i_var, arg[0], npv, ForJac
     234                        );
    259235                        break;
    260236                        // -------------------------------------------------
    261237
    262238                        case AsinOp:
    263                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    264                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    265 
    266239                        // asin(x) and sqrt(1 - x * x) are computed in pairs
    267                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
    268                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    269 
    270                         // use Tmp for data stored in variable record
    271                         Tmp = ForJac + (i_var+1) * npv;
    272                         X   = ForJac + ind[0] * npv;
    273                         for(j = 0; j < npv; j++)
    274                                 Tmp[j] = Z[j] = X[j];
     240                        // but ivar + 1 should only be used here
     241                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     242                        forward_sparse_jacobian_unary_op(
     243                                i_var, arg[0], npv, ForJac
     244                        );
    275245                        break;
    276246                        // -------------------------------------------------
    277247
    278248                        case AtanOp:
    279                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    280                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    281 
    282249                        // atan(x) and 1 + x * x must be computed in pairs
    283                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
    284                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    285 
    286                         // use Tmp for data stored in variable record
    287                         Tmp = ForJac + (i_var+1) * npv;
    288                         X   = ForJac + ind[0] * npv;
    289                         for(j = 0; j < npv; j++)
    290                                 Tmp[j] = Z[j] = X[j];
     250                        // but ivar + 1 should only be used here
     251                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     252                        forward_sparse_jacobian_unary_op(
     253                                i_var, arg[0], npv, ForJac
     254                        );
    291255                        break;
    292256                        // -------------------------------------------------
    293257
    294258                        case CExpOp:
    295                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    296                         CPPAD_ASSERT_UNKNOWN( n_ind == 6);
    297                         CPPAD_ASSERT_UNKNOWN( ind[1] != 0 );
    298 
    299                         if( ind[1] & 4 )
    300                                 trueCase = ForJac + ind[4] * npv;
     259                        CPPAD_ASSERT_NARG_NRES(op, 6, 1);
     260                        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
     261
     262                        if( arg[1] & 4 )
     263                                trueCase = ForJac + arg[4] * npv;
    301264                        else    trueCase = zero;
    302                         if( ind[1] & 8 )
    303                                 falseCase = ForJac + ind[5] * npv;
     265                        if( arg[1] & 8 )
     266                                falseCase = ForJac + arg[5] * npv;
    304267                        else    falseCase = zero;
    305268                        if( ! use_VecAD )
     
    310273                        else
    311274                        {       // result only valid for current values
    312                                 if( ind[1] & 1 )
    313                                         left = Taylor + ind[2] * TaylorColDim;
    314                                 else    left = Rec->GetPar(ind[2]);
    315                                 if( ind[1] & 2 )
    316                                         right = Taylor + ind[3] * TaylorColDim;
    317                                 else    right = Rec->GetPar(ind[3]);
     275                                if( arg[1] & 1 )
     276                                        left = Taylor + arg[2] * TaylorColDim;
     277                                else    left = Rec->GetPar(arg[2]);
     278                                if( arg[1] & 2 )
     279                                        right = Taylor + arg[3] * TaylorColDim;
     280                                else    right = Rec->GetPar(arg[3]);
    318281                                for(j = 0; j < npv; j++)
    319282                                {       Z[j] = CondExpTemplate(
    320                                                 CompareOp( ind[0] ),
     283                                                CompareOp( arg[0] ),
    321284                                                *left,
    322285                                                *right,
     
    331294
    332295                        case ComOp:
    333                         CPPAD_ASSERT_UNKNOWN( n_var == 0 );
    334                         CPPAD_ASSERT_UNKNOWN( n_ind == 4 );
    335                         CPPAD_ASSERT_UNKNOWN( ind[1] > 1 );
     296                        CPPAD_ASSERT_NARG_NRES(op, 4, 0);
     297                        CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
    336298                        break;
    337299                        // --------------------------------------------------
    338300
    339301                        case CosOp:
    340                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    341                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    342 
    343302                        // cosine and sine must come in pairs
    344                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
    345                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    346 
    347                         // use Tmp for data stored in variable record
    348                         Tmp = ForJac + (i_var+1) * npv;
    349                         X   = ForJac + ind[0] * npv;
    350                         for(j = 0; j < npv; j++)
    351                                 Tmp[j] = Z[j] = X[j];
     303                        // but ivar + 1 should only be used here
     304                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     305                        forward_sparse_jacobian_unary_op(
     306                                i_var, arg[0], npv, ForJac
     307                        );
    352308                        break;
    353309                        // ---------------------------------------------------
    354310
    355311                        case CoshOp:
    356                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    357                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    358 
    359312                        // hyperbolic cosine and sine must come in pairs
    360                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
    361                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    362 
    363                         // use Tmp for data stored in variable record
    364                         Tmp = ForJac + (i_var+1) * npv;
    365                         X   = ForJac + ind[0] * npv;
    366                         for(j = 0; j < npv; j++)
    367                                 Tmp[j] = Z[j] = X[j];
     313                        // but ivar + 1 should only be used here
     314                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     315                        forward_sparse_jacobian_unary_op(
     316                                i_var, arg[0], npv, ForJac
     317                        );
    368318                        break;
    369319                        // -------------------------------------------------
    370320
    371321                        case DisOp:
    372                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    373                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
     322                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
    374323
    375324                        for(j = 0; j < npv; j++)
     
    379328
    380329                        case DivvvOp:
    381                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    382                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    383                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    384                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    385 
    386                         X = ForJac + ind[0] * npv;
    387                         Y = ForJac + ind[1] * npv;
     330                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     331                        CPPAD_ASSERT_UNKNOWN( arg[0] < i_var );
     332                        CPPAD_ASSERT_UNKNOWN( arg[1] < i_var );
     333
     334                        X = ForJac + arg[0] * npv;
     335                        Y = ForJac + arg[1] * npv;
    388336                        for(j = 0; j < npv; j++)
    389337                                Z[j] = X[j] | Y[j];
     
    392340
    393341                        case DivpvOp:
    394                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    395                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    396                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    397 
    398                         Y = ForJac + ind[1] * npv;
    399                         for(j = 0; j < npv; j++)
    400                                 Z[j] = Y[j];
     342                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     343                        forward_sparse_jacobian_unary_op(
     344                                i_var, arg[1], npv, ForJac
     345                        );
    401346                        break;
    402347                        // -------------------------------------------------
    403348
    404349                        case DivvpOp:
    405                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    406                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    407                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    408 
    409                         X = ForJac + ind[0] * npv;
    410                         for(j = 0; j < npv; j++)
    411                                 Z[j] = X[j];
     350                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     351                        forward_sparse_jacobian_unary_op(
     352                                i_var, arg[0], npv, ForJac
     353                        );
    412354                        break;
    413355                        // -------------------------------------------------
    414356
    415357                        case ExpOp:
    416                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    417                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    418                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    419 
    420                         X = ForJac + ind[0] * npv;
    421                         for(j = 0; j < npv; j++)
    422                                 Z[j] = X[j];
     358                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     359                        forward_sparse_jacobian_unary_op(
     360                                i_var, arg[0], npv, ForJac
     361                        );
    423362                        break;
    424363                        // -------------------------------------------------
    425364
    426365                        case InvOp:
    427                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    428                         CPPAD_ASSERT_UNKNOWN( n_ind == 0 );
     366                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    429367                        // Z is already defined
    430368                        break;
     
    432370
    433371                        case LdpOp:
    434                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    435                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
     372                        CPPAD_ASSERT_NARG_NRES(op, 3, 1);
    436373                       
    437                         CPPAD_ASSERT_UNKNOWN( ind[0] > 0 );
    438                         CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->num_rec_vecad_ind() );
    439 
    440                         // ind[2] is variable corresponding to this load
    441                         if( ind[2] > 0 )
    442                         {       X = ForJac + ind[2] * npv;
     374                        CPPAD_ASSERT_UNKNOWN( arg[0] > 0 );
     375                        CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_vecad_ind() );
     376
     377                        // arg[2] is variable corresponding to this load
     378                        if( arg[2] > 0 )
     379                        {       X = ForJac + arg[2] * npv;
    443380                                for(j = 0; j < npv; j++)
    444381                                        Z[j] = X[j];
     
    452389
    453390                        case LdvOp:
    454                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    455                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
     391                        CPPAD_ASSERT_NARG_NRES(op, 3, 1);
    456392                       
    457                         CPPAD_ASSERT_UNKNOWN( ind[0] > 0 );
    458                         CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->num_rec_vecad_ind() );
    459 
    460 
    461                         // ind[2] is variable corresponding to this load
    462                         if( ind[2] > 0 )
    463                         {       X = ForJac + ind[2] * npv;
     393                        CPPAD_ASSERT_UNKNOWN( arg[0] > 0 );
     394                        CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_vecad_ind() );
     395
     396
     397                        // arg[2] is variable corresponding to this load
     398                        if( arg[2] > 0 )
     399                        {       X = ForJac + arg[2] * npv;
    464400                                for(j = 0; j < npv; j++)
    465401                                        Z[j] = X[j];
     
    473409
    474410                        case LogOp:
    475                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    476                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    477                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    478 
    479                         X = ForJac + ind[0] * npv;
    480                         for(j = 0; j < npv; j++)
    481                                 Z[j] = X[j];
     411                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     412                        forward_sparse_jacobian_unary_op(
     413                                i_var, arg[0], npv, ForJac
     414                        );
    482415                        break;
    483416                        // -------------------------------------------------
    484417
    485418                        case MulvvOp:
    486                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    487                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    488                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    489                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    490 
    491                         X = ForJac + ind[0] * npv;
    492                         Y = ForJac + ind[1] * npv;
     419                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     420                        CPPAD_ASSERT_UNKNOWN( arg[0] < i_var );
     421                        CPPAD_ASSERT_UNKNOWN( arg[1] < i_var );
     422
     423                        X = ForJac + arg[0] * npv;
     424                        Y = ForJac + arg[1] * npv;
    493425                        for(j = 0; j < npv; j++)
    494426                                Z[j] = X[j] | Y[j];
     
    497429
    498430                        case MulpvOp:
    499                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    500                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    501                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    502 
    503                         Y = ForJac + ind[1] * npv;
    504                         for(j = 0; j < npv; j++)
    505                                 Z[j] = Y[j];
     431                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     432                        forward_sparse_jacobian_unary_op(
     433                                i_var, arg[1], npv, ForJac
     434                        );
    506435                        break;
    507436                        // -------------------------------------------------
    508437
    509438                        case MulvpOp:
    510                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    511                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    512                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    513 
    514                         X = ForJac + ind[0] * npv;
    515                         for(j = 0; j < npv; j++)
    516                                 Z[j] = X[j];
     439                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     440                        forward_sparse_jacobian_unary_op(
     441                                i_var, arg[0], npv, ForJac
     442                        );
    517443                        break;
    518444                        // -------------------------------------------------
    519445
    520446                        case NonOp:
    521                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    522                         CPPAD_ASSERT_UNKNOWN( n_ind == 0 );
     447                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    523448                        for(j = 0; j < npv; j++)
    524449                                Z[j] = 0;
     
    526451
    527452                        case ParOp:
    528                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    529                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
     453                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    530454                        for(j = 0; j < npv; j++)
    531455                                Z[j] = 0;
     
    534458
    535459                        case PowvpOp:
    536                         CPPAD_ASSERT_UNKNOWN( n_var == 3 );
    537                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    538                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    539 
    540                         X = ForJac + ind[0] * npv;
    541                         for(j = 0; j < npv; j++)
    542                                 Z[j] = X[j];
     460                        // Pow operator is a special case where final result
     461                        // comes at the end of the three variables
     462                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
     463                        forward_sparse_jacobian_unary_op(
     464                                i_var + 2, arg[0], npv, ForJac
     465                        );
    543466                        break;
    544467                        // -------------------------------------------------
    545468
    546469                        case PowpvOp:
    547                         CPPAD_ASSERT_UNKNOWN( n_var == 3 );
    548                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    549                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    550 
    551                         Y = ForJac + ind[1] * npv;
    552                         for(j = 0; j < npv; j++)
    553                                 Z[j] = Y[j];
     470                        // Pow operator is a special case where final result
     471                        // comes at the end of the three variables
     472                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
     473                        forward_sparse_jacobian_unary_op(
     474                                i_var + 2, arg[1], npv, ForJac
     475                        );
    554476                        break;
    555477                        // -------------------------------------------------
    556478
    557479                        case PowvvOp:
    558                         CPPAD_ASSERT_UNKNOWN( n_var == 3 );
    559                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    560                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    561                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    562 
    563                         X = ForJac + ind[0] * npv;
    564                         Y = ForJac + ind[1] * npv;
     480                        // Pow operator is a special case where final result
     481                        // comes at the end of the three variables
     482                        Z   += 2 * npv;
     483                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
     484                        CPPAD_ASSERT_UNKNOWN( arg[0] < i_var );
     485                        CPPAD_ASSERT_UNKNOWN( arg[1] < i_var );
     486
     487                        X = ForJac + arg[0] * npv;
     488                        Y = ForJac + arg[1] * npv;
    565489                        for(j = 0; j < npv; j++)
    566490                                Z[j] = X[j] | Y[j];
     
    569493
    570494                        case PripOp:
    571                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
     495                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    572496                        for(j = 0; j < npv; j++)
    573497                                Z[j] = 0;
     
    576500
    577501                        case PrivOp:
    578                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
     502                        CPPAD_ASSERT_NARG_NRES(op, 2, 0);
    579503                        break;
    580504                        // -------------------------------------------------
    581505
    582506                        case SinOp:
    583                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    584                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    585 
    586507                        // sine and cosine must come in pairs
    587                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
    588                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    589 
    590                         // use Tmp for data stored in second variable
    591                         Tmp = ForJac + (i_var+1) * npv;
    592                         X   = ForJac + ind[0] * npv;
    593                         for(j = 0; j < npv; j++)
    594                                 Z[j] = Tmp[j] = X[j];
     508                        // but ivar + 1 should only be used here
     509                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     510                        forward_sparse_jacobian_unary_op(
     511                                i_var, arg[0], npv, ForJac
     512                        );
    595513                        break;
    596514                        // -------------------------------------------------
    597515
    598516                        case SinhOp:
    599                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    600                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    601 
    602                         // sine and cosine must come in pairs
    603                         CPPAD_ASSERT_UNKNOWN( n_var == 2);
    604                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    605 
    606                         // use Tmp for data stored in second variable
    607                         Tmp = ForJac + (i_var+1) * npv;
    608                         X   = ForJac + ind[0] * npv;
    609                         for(j = 0; j < npv; j++)
    610                                 Z[j] = Tmp[j] = X[j];
     517                        // hyperbolic sine and cosine must come in pairs
     518                        // but ivar + 1 should only be used here
     519                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
     520                        forward_sparse_jacobian_unary_op(
     521                                i_var, arg[0], npv, ForJac
     522                        );
    611523                        break;
    612524                        // -------------------------------------------------
    613525
    614526                        case SqrtOp:
    615                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    616                         CPPAD_ASSERT_UNKNOWN( n_ind == 1 );
    617                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    618 
    619                         X = ForJac + ind[0] * npv;
    620                         for(j = 0; j < npv; j++)
    621                                 Z[j] = X[j];
     527                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     528                        forward_sparse_jacobian_unary_op(
     529                                i_var, arg[0], npv, ForJac
     530                        );
    622531                        break;
    623532                        // -------------------------------------------------
    624533
    625534                        case StppOp:
    626                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
    627                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
     535                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
    628536                        break;
    629537                        // -------------------------------------------------
    630538
    631539                        case StpvOp:
    632                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
    633                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
     540                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
    634541                        break;
    635542                        // -------------------------------------------------
    636543
    637544                        case StvpOp:
    638                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
    639                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
     545                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
    640546                        break;
    641547                        // -------------------------------------------------
    642548
    643549                        case StvvOp:
    644                         CPPAD_ASSERT_UNKNOWN( n_var == 0);
    645                         CPPAD_ASSERT_UNKNOWN( n_ind == 3 );
     550                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
    646551                        break;
    647552                        // -------------------------------------------------
    648553
    649554                        case SubvvOp:
    650                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    651                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    652                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    653                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    654 
    655                         X = ForJac + ind[0] * npv;
    656                         Y = ForJac + ind[1] * npv;
     555                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     556                        CPPAD_ASSERT_UNKNOWN( arg[0] < i_var );
     557                        CPPAD_ASSERT_UNKNOWN( arg[1] < i_var );
     558
     559                        X = ForJac + arg[0] * npv;
     560                        Y = ForJac + arg[1] * npv;
    657561                        for(j = 0; j < npv; j++)
    658562                                Z[j] = X[j] | Y[j];
     
    661565
    662566                        case SubpvOp:
    663                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    664                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    665                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    666 
    667                         Y = ForJac + ind[1] * npv;
    668                         for(j = 0; j < npv; j++)
    669                                 Z[j] = Y[j];
     567                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     568                        forward_sparse_jacobian_unary_op(
     569                                i_var, arg[1], npv, ForJac
     570                        );
    670571                        break;
    671572                        // -------------------------------------------------
    672573
    673574                        case SubvpOp:
    674                         CPPAD_ASSERT_UNKNOWN( n_var == 1);
    675                         CPPAD_ASSERT_UNKNOWN( n_ind == 2 );
    676                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    677 
    678                         X = ForJac + ind[0] * npv;
    679                         for(j = 0; j < npv; j++)
    680                                 Z[j] = X[j];
     575                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
     576                        forward_sparse_jacobian_unary_op(
     577                                i_var, arg[0], npv, ForJac
     578                        );
    681579                        break;
    682580                        // -------------------------------------------------
     
    691589                        i_var,
    692590                        op,
    693                         ind,
     591                        arg,
    694592                        npv,
    695593                        Z,
     
    702600        }
    703601# endif
    704         CPPAD_ASSERT_UNKNOWN( (i_var + n_var) == Rec->num_rec_var() );
     602        CPPAD_ASSERT_UNKNOWN( (i_var + NumRes(op) ) == Rec->num_rec_var() );
    705603
    706604        // free vector of zeros
  • trunk/cppad/local/forward0sweep.hpp

    r1401 r1447  
    155155{
    156156        // some constants
    157         Base one(1);
    158 
    159157        size_t     numop_m1;
    160158        OpCode           op;
    161159        size_t         i_op;
    162160        size_t        i_var;
    163         size_t        i_ind;
    164 
    165         const size_t   *ind = 0;
    166         const size_t *ind_0 = 0;
     161        size_t        i_arg;
     162
     163        const size_t   *arg = 0;
     164        const size_t *arg_0 = 0;
    167165        const Base       *P = 0;
    168166        const Base       *X = 0;
     
    170168
    171169        // used by CExp operator (left and right also used by Com operator)
    172         const Base  *left = 0, *right = 0, *trueCase = 0, *falseCase = 0;
     170        const Base  *left = 0, *right = 0;
    173171
    174172        // used by Com operator
     
    176174
    177175        Base             *Z = 0;
    178         Base             *W = 0;
    179         Base             *U = 0;
    180176
    181177        size_t          i;
    182178        size_t          len;
    183         size_t          n_var = 0;
    184         size_t          n_ind = 0;
     179        size_t          n_res = 0;
     180        size_t          n_arg = 0;
    185181
    186182
     
    213209        numop_m1 = Rec->num_rec_op() - 1;
    214210
     211        // length of the parameter vector (used by CppAD assert macros)
     212        const size_t num_par = Rec->num_rec_par();
     213
     214        // pointer to the beginning of the parameter vector
     215        const Base* parameter = 0;
     216        if( num_par > 0 )
     217                parameter = Rec->GetPar(0);
     218
    215219        // skip the NonOp at the beginning of the recording
    216         Rec->start_forward(op, ind, i_op, i_var);
    217         ind_0 = ind;
     220        Rec->start_forward(op, arg, i_op, i_var);
     221        arg_0 = arg;
    218222        while(i_op < numop_m1)
    219223        {
    220224                // this op
    221                 Rec->next_forward(op, ind, i_op, i_var);
     225                Rec->next_forward(op, arg, i_op, i_var);
    222226
    223227                // number of variables
    224                 n_var  = NumVar(op);
     228                n_res  = NumRes(op);
    225229
    226230                // index field values for this op
    227                 n_ind  = NumInd(op);
     231                n_arg  = NumArg(op);
    228232
    229233                // value of z for this op
     
    235239                {
    236240                        case AbsOp:
    237                         forward_abs_op_0(i_var, ind, J, Taylor);
     241                        forward_abs_op_0(i_var, arg[0], J, Taylor);
    238242                        break;
    239243                        // -------------------------------------------------
    240244
    241245                        case AddvvOp:
    242                         n_var = 1;
    243                         n_ind = 2;
    244                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    245                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    246 
    247                         X = Taylor + ind[0] * J;
    248                         Y = Taylor + ind[1] * J;
    249                         Z[0] = X[0] + Y[0];
     246                        forward_addvv_op_0(i_var, arg, parameter, J, Taylor);
    250247                        break;
    251248                        // -------------------------------------------------
    252249
    253250                        case AddpvOp:
    254                         n_var = 1;
    255                         n_ind = 2;
    256                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    257 
    258                         P = CPPAD_GET_PAR(ind[0]);
    259                         Y = Taylor + ind[1] * J;
    260                         Z[0] = P[0] + Y[0];
     251                        CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
     252                        forward_addpv_op_0(i_var, arg, parameter, J, Taylor);
    261253                        break;
    262254                        // -------------------------------------------------
    263255
    264256                        case AddvpOp:
    265                         n_var = 1;
    266                         n_ind = 2;
    267                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    268 
    269                         X = Taylor + ind[0] * J;
    270                         P = CPPAD_GET_PAR(ind[1]);
    271                         Z[0] = X[0] + P[0];
     257                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
     258                        forward_addvp_op_0(i_var, arg, parameter, J, Taylor);
    272259                        break;
    273260                        // -------------------------------------------------
    274261
    275262                        case AcosOp:
    276                         // variables: acos(x),  sqrt(1 - x * x)
    277                         n_ind = 1;
    278                         n_var = 2;
    279                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
     263                        // results: acos(x),  sqrt(1 - x * x)
    280264                        CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    281 
    282                         // use W for data stored in variable record
    283                         W = Taylor + (i_var+1) * J;
    284                         X = Taylor + ind[0] * J;
    285                         W[0] = sqrt( one - X[0] * X[0] );
    286                         Z[0] = acos( X[0] );
     265                        forward_acos_op_0(i_var, arg[0], J, Taylor);
    287266                        break;
    288267                        // -------------------------------------------------
    289268
    290269                        case AsinOp:
    291                         // variables: asin(x),  sqrt(1 - x * x)
    292                         n_ind = 1;
    293                         n_var = 2;
    294                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
     270                        // results: asin(x),  sqrt(1 - x * x)
    295271                        CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    296 
    297                         // use W for data stored in variable record
    298                         W = Taylor + (i_var+1) * J;
    299                         X = Taylor + ind[0] * J;
    300                         W[0] = sqrt( one - X[0] * X[0] );
    301                         Z[0] = asin( X[0] );
     272                        forward_asin_op_0(i_var, arg[0], J, Taylor);
    302273                        break;
    303274                        // -------------------------------------------------
    304275
    305276                        case AtanOp:
    306                         // variables: atan(x),  1 + x * x
    307                         n_ind = 1;
    308                         n_var = 2;
    309                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
     277                        // results: atan(x),  1 + x * x
    310278                        CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    311 
    312                         // use W for data stored in variable record
    313                         W = Taylor + (i_var+1) * J;
    314                         X = Taylor + ind[0] * J;
    315                         W[0] = one + X[0] * X[0];
    316                         Z[0] = atan( X[0] );
     279                        forward_atan_op_0(i_var, arg[0], J, Taylor);
    317280                        break;
    318281                        // -------------------------------------------------
    319282
    320283                        case CExpOp:
    321                         n_var = 1;
    322                         n_ind = 6;
    323                         CPPAD_ASSERT_UNKNOWN( ind[1] != 0 );
    324                         if( ind[1] & 1 )
    325                                 left = Taylor + ind[2] * J;
    326                         else    left = CPPAD_GET_PAR(ind[2]);
    327                         if( ind[1] & 2 )
    328                                 right = Taylor + ind[3] * J;
    329                         else    right = CPPAD_GET_PAR(ind[3]);
     284                        // Use the general case with d == 0
     285                        // (could create an optimzied verison for this case)
     286                        forward_cond_op_0(
     287                                i_var, arg, num_par, parameter, J, Taylor
     288                        );
     289                        break;
     290                        // ---------------------------------------------------
     291
     292                        case ComOp:
     293                        n_res = 0;
     294                        n_arg = 4;
     295                        CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
    330296                        // d == 0
    331                         {       if( ind[1] & 4 )
    332                                         trueCase = Taylor + ind[4] * J;
    333                                 else    trueCase = CPPAD_GET_PAR(ind[4]);
    334                                 if( ind[1] & 8 )
    335                                         falseCase = Taylor + ind[5] * J;
    336                                 else    falseCase = CPPAD_GET_PAR(ind[5]);
    337                         }
    338                         Z[0] = CondExpOp(
    339                                 CompareOp( ind[0] ),
    340                                 *left,
    341                                 *right,
    342                                 *trueCase,
    343                                 *falseCase
    344                         );
    345                         break;
    346                         // ---------------------------------------------------
    347 
    348                         case ComOp:
    349                         n_var = 0;
    350                         n_ind = 4;
    351                         CPPAD_ASSERT_UNKNOWN( ind[1] > 1 );
    352                         // d == 0
    353                         {       if( ind[1] & 1 )
     297                        {       if( arg[1] & 1 )
    354298                                        result = true;
    355299                                else    result = false;
    356                                 if( ind[1] & 2 )
    357                                         left = Taylor + ind[2] * J;
    358                                 else    left = CPPAD_GET_PAR(ind[2]);
    359                                 if( ind[1] & 4 )
    360                                         right = Taylor + ind[3] * J;
    361                                 else    right = CPPAD_GET_PAR(ind[3]);
    362                                 switch( CompareOp( ind[0] ) )
     300                                if( arg[1] & 2 )
     301                                        left = Taylor + arg[2] * J;
     302                                else    left = CPPAD_GET_PAR(arg[2]);
     303                                if( arg[1] & 4 )
     304                                        right = Taylor + arg[3] * J;
     305                                else    right = CPPAD_GET_PAR(arg[3]);
     306                                switch( CompareOp( arg[0] ) )
    363307                                {       case CompareLt:
    364308                                        compareCount += ( result !=
     
    399343
    400344                        case CosOp:
    401                         // variables: cos(x), sin(x)
    402                         n_ind = 1;
    403                         n_var = 2;
    404                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
     345                        // results: cos(x), sin(x)
    405346                        CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    406 
    407                         // use W for data stored in variable record
    408                         W = Taylor + (i_var+1) * J;
    409                         X = Taylor + ind[0] * J;
    410                         W[0] = sin( X[0] );
    411                         Z[0] = cos( X[0] );
     347                        forward_cos_op_0(i_var, arg[0], J, Taylor);
    412348                        break;
    413349                        // ---------------------------------------------------
     
    415351                        case CoshOp:
    416352                        // variables: cosh(x), sinh(x)
    417                         n_ind = 1;
    418                         n_var = 2;
    419                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    420353                        CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar  );
    421 
    422                         // use W for data stored in variable record
    423                         W = Taylor + (i_var+1) * J;
    424                         X = Taylor + ind[0] * J;
    425                         W[0] = sinh( X[0] );
    426                         Z[0] = cosh( X[0] );
     354                        forward_cosh_op_0(i_var, arg[0], J, Taylor);
    427355                        break;
    428356                        // -------------------------------------------------
    429357
    430358                        case DisOp:
    431                         n_var = 1;
    432                         n_ind = 2;
    433                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
     359                        n_res = 1;
     360                        n_arg = 2;
     361                        CPPAD_ASSERT_UNKNOWN( arg[0] < i_var );
    434362                        // d == 0
    435                         {       X   = Taylor + ind[0] * J;
    436                                 Z[0] = ADDiscrete<Base>::Eval(ind[1], X[0]);
     363                        {       X   = Taylor + arg[0] * J;
     364                                Z[0] = ADDiscrete<Base>::Eval(arg[1], X[0]);
    437365                        }
    438366                        break;
     
    440368
    441369                        case DivvvOp:
    442                         n_var = 1;
    443                         n_ind = 2;
    444                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    445                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    446 
    447                         X = Taylor + ind[0] * J;
    448                         Y = Taylor + ind[1] * J;
    449                         Z[0] = X[0] / Y[0];
     370                        forward_divvv_op_0(i_var, arg, parameter, J, Taylor);
    450371                        break;
    451372                        // -------------------------------------------------
    452373
    453374                        case DivpvOp:
    454                         n_var = 1;
    455                         n_ind = 2;
    456                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    457 
    458                         Y = Taylor + ind[1] * J;
    459                         P = CPPAD_GET_PAR(ind[0]);
    460                         Z[0] = P[0] / Y[0];
     375                        CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
     376                        forward_divpv_op_0(i_var, arg, parameter, J, Taylor);
    461377                        break;
    462378                        // -------------------------------------------------
    463379
    464380                        case DivvpOp:
    465                         n_var = 1;
    466                         n_ind = 2;
    467                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    468 
    469                         P = CPPAD_GET_PAR(ind[1]);
    470                         X = Taylor + ind[0] * J;
    471                         Z[0] = X[0] / P[0];
     381                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
     382                        forward_divvp_op_0(i_var, arg, parameter, J, Taylor);
    472383                        break;
    473384                        // -------------------------------------------------
    474385
    475386                        case ExpOp:
    476                         n_var = 1;
    477                         n_ind = 1;
    478                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    479 
    480                         X = Taylor + ind[0] * J;
    481                         Z[0] = exp( X[0] );
     387                        forward_exp_op_0(i_var, arg[0], J, Taylor);
    482388                        break;
    483389                        // -------------------------------------------------
    484390
    485391                        case InvOp:
    486                         n_var = 1;
    487                         n_ind = 0;
     392                        n_res = 1;
     393                        n_arg = 0;
    488394                        break;
    489395                        // -------------------------------------------------
    490396
    491397                        case LdpOp:
    492                         n_var = 1;
    493                         n_ind = 3;
     398                        n_res = 1;
     399                        n_arg = 3;
    494400                       
    495                         CPPAD_ASSERT_UNKNOWN( ind[0] > 0 );
    496                         CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->num_rec_vecad_ind() );
     401                        CPPAD_ASSERT_UNKNOWN( arg[0] > 0 );
     402                        CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_vecad_ind() );
    497403                        CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
    498404                        CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
    499405
    500406                        // d == 0
    501                         {       i   = ind[1];
     407                        {       i   = arg[1];
    502408                                CPPAD_ASSERT_UNKNOWN(
    503                                         i < VectorInd[ind[0] - 1]
     409                                        i < VectorInd[arg[0] - 1]
    504410                                );
    505411                                CPPAD_ASSERT_UNKNOWN(
    506                                         i + ind[0] < Rec->num_rec_vecad_ind()
    507                                 );
    508 
    509                                 if( VectorVar[ i + ind[0] ] )
    510                                 {       i     = VectorInd[ i + ind[0] ];
    511                                         i_ind = ind - ind_0;
    512                                         Rec->ReplaceInd(i_ind + 2, i);
     412                                        i + arg[0] < Rec->num_rec_vecad_ind()
     413                                );
     414
     415                                if( VectorVar[ i + arg[0] ] )
     416                                {       i     = VectorInd[ i + arg[0] ];
     417                                        i_arg = arg - arg_0;
     418                                        Rec->ReplaceInd(i_arg + 2, i);
    513419                                        CPPAD_ASSERT_UNKNOWN(i > 0 );
    514420                                        CPPAD_ASSERT_UNKNOWN( i < i_var );
     
    517423                                }
    518424                                else
    519                                 {       i     = VectorInd[ i + ind[0] ];
    520                                         i_ind = ind - ind_0;
    521                                         Rec->ReplaceInd(i_ind + 2, 0);
     425                                {       i     = VectorInd[ i + arg[0] ];
     426                                        i_arg = arg - arg_0;
     427                                        Rec->ReplaceInd(i_arg + 2, 0);
    522428                                        Z[0] = *(CPPAD_GET_PAR(i));
    523429                                        i    = 0;
     
    528434
    529435                        case LdvOp:
    530                         n_var = 1;
    531                         n_ind = 3;
     436                        n_res = 1;
     437                        n_arg = 3;
    532438                       
    533                         CPPAD_ASSERT_UNKNOWN( ind[0] > 0 );
    534                         CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->num_rec_vecad_ind() );
     439                        CPPAD_ASSERT_UNKNOWN( arg[0] > 0 );
     440                        CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_vecad_ind() );
    535441                        CPPAD_ASSERT_UNKNOWN( VectorInd != CPPAD_NULL );
    536442                        CPPAD_ASSERT_UNKNOWN( VectorVar != CPPAD_NULL );
     
    538444                        // d == 0
    539445                        {
    540                                 X   = Taylor + ind[1] * J;
     446                                X   = Taylor + arg[1] * J;
    541447                                i   = Integer( X[0] );
    542                                 len = VectorInd[ ind[0] - 1 ];
     448                                len = VectorInd[ arg[0] - 1 ];
    543449                                CPPAD_ASSERT_KNOWN(
    544450                                        i < len,
     
    546452                                );
    547453                                CPPAD_ASSERT_UNKNOWN(
    548                                         i + ind[0] < Rec->num_rec_vecad_ind()
    549                                 );
    550 
    551                                 if( VectorVar[ i + ind[0] ] )
    552                                 {       i     = VectorInd[ i + ind[0] ];
    553                                         i_ind = ind - ind_0;
    554                                         Rec->ReplaceInd(i_ind + 2, i);
     454                                        i + arg[0] < Rec->num_rec_vecad_ind()
     455                                );
     456
     457                                if( VectorVar[ i + arg[0] ] )
     458                                {       i     = VectorInd[ i + arg[0] ];
     459                                        i_arg = arg - arg_0;
     460                                        Rec->ReplaceInd(i_arg + 2, i);
    555461                                        CPPAD_ASSERT_UNKNOWN(i > 0 );
    556462                                        CPPAD_ASSERT_UNKNOWN( i < i_var );
     
    559465                                }
    560466                                else
    561                                 {       i     = VectorInd[ i + ind[0] ];
    562                                         i_ind = ind - ind_0;
    563                                         Rec->ReplaceInd(i_ind + 2, 0);
     467                                {       i     = VectorInd[ i + arg[0] ];
     468                                        i_arg = arg - arg_0;
     469                                        Rec->ReplaceInd(i_arg + 2, 0);
    564470                                        Z[0] = *(CPPAD_GET_PAR(i));
    565471                                        i    = 0;
     
    570476
    571477                        case LogOp:
    572                         n_var = 1;
    573                         n_ind = 1;
    574                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    575 
    576                         X = Taylor + ind[0] * J;
    577                         Z[0] = log( X[0] );
     478                        forward_log_op_0(i_var, arg[0], J, Taylor);
    578479                        break;
    579480                        // -------------------------------------------------
    580481
    581482                        case MulvvOp:
    582                         n_var = 1;
    583                         n_ind = 2;
    584                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    585                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    586 
    587                         X = Taylor + ind[0] * J;
    588                         Y = Taylor + ind[1] * J;
    589                         Z[0] = X[0] * Y[0];
     483                        forward_mulvv_op_0(i_var, arg, parameter, J, Taylor);
    590484                        break;
    591485                        // -------------------------------------------------
    592486
    593487                        case MulpvOp:
    594                         n_var = 1;
    595                         n_ind = 2;
    596                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    597 
    598                         Y = Taylor + ind[1] * J;
    599                         P = CPPAD_GET_PAR(ind[0]);
    600                         Z[0] = P[0] * Y[0];
     488                        CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
     489                        forward_mulpv_op_0(i_var, arg, parameter, J, Taylor);
    601490                        break;
    602491                        // -------------------------------------------------
    603492
    604493                        case MulvpOp:
    605                         n_var = 1;
    606                         n_ind = 2;
    607                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var );
    608 
    609                         X = Taylor + ind[0] * J;
    610                         P = CPPAD_GET_PAR(ind[1]);
    611                         Z[0] = X[0] * P[0];
     494                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
     495                        forward_mulvp_op_0(i_var, arg, parameter, J, Taylor);
    612496                        break;
    613497                        // -------------------------------------------------
    614498
    615499                        case NonOp:
    616                         n_var = 1;
    617                         n_ind = 0;
     500                        n_res = 1;
     501                        n_arg = 0;
    618502                        break;
    619503                        // -------------------------------------------------
    620504
    621505                        case ParOp:
    622                         n_var = 1;
    623                         n_ind = 1;
    624 
    625                         P = CPPAD_GET_PAR(ind[0]);
     506                        n_res = 1;
     507                        n_arg = 1;
     508
     509                        P = CPPAD_GET_PAR(arg[0]);
    626510                        Z[0] = *P;
    627511                        break;
     
    629513
    630514                        case PowvpOp:
    631                         // variables: pow(x, y), log(x), y * log(x)
    632                         n_var = 3;
    633                         n_ind = 2;
    634                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var);
    635                         U = Z + J;
    636                         W = U + J;
    637 
    638                         // u = log(x)
    639                         X = Taylor + ind[0] * J;
    640                         U[0] = log( X[0] );
    641 
    642                         // w = u * y
    643                         Y = CPPAD_GET_PAR(ind[1]);
    644                         W[0] = U[0] * Y[0];
    645 
    646                         // z = exp(w)
    647                         // zero order case exactly same as Base type operation
    648                         // d == 0
    649                         Z[0] = pow(X[0], Y[0]);
    650 
     515                        CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
     516                        forward_powvp_op_0(i_var, arg, parameter, J, Taylor);
    651517                        break;
    652518                        // -------------------------------------------------
    653519
    654520                        case PowpvOp:
    655                         // variables: pow(x, y), log(x), y * log(x)
    656                         n_var = 3;
    657                         n_ind = 2;
    658                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var);
    659                         U = Z + J;
    660                         W = U + J;
    661 
    662                         // u = log(x)
    663                         X = CPPAD_GET_PAR(ind[0]);
    664                         U[0] = log(X[0]);
    665 
    666                         // w = u * y
    667                         Y = Taylor + ind[1] * J;
    668                         W[0] = U[0] * Y[0];
    669 
    670                         // z = exp(w)
    671                         // zero order case exactly same as Base type operation
    672                         Z[0] = pow(X[0], Y[0]);
    673 
     521                        CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
     522                        forward_powpv_op_0(i_var, arg, parameter, J, Taylor);
    674523                        break;
    675524                        // -------------------------------------------------
    676525
    677526                        case PowvvOp:
    678                         // variables: pow(x, y), log(x), y * log(x)
    679                         n_var = 3;
    680                         n_ind = 2;
    681                         CPPAD_ASSERT_UNKNOWN( ind[0] < i_var);
    682                         CPPAD_ASSERT_UNKNOWN( ind[1] < i_var);
    683                         U = Z + J;
    684                         W = U + J;
    685 
    686                         // u = log(x)
    687                         X = Taylor + ind[0] * J;
    688                         U[0] = log( X[0] );
    689 
    690                         // w = u * y
    691                         Y = Taylor + ind[1] * J;
    692                         W[0] = U[0] * Y[0];
    693 
    694                         // z = exp(w)
    695                         // zero order case exactly same as Base type operation
    696                         Z[0] = pow(X[0], Y[0]);
    697 
     527                        forward_powvv_op_0(i_var, arg, parameter, J, Taylor);
    698528                        break;
    699529                        // -------------------------------------------------
    700530
    701531                        case PripOp:
    702                         n_var = 0;
    703                         n_ind = 2;
     532                        n_res = 0;
     533                        n_arg = 2;
    704534                        if( print )
    705                         {       CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->num_rec_text() );
    706                                 std::cout << Rec->GetTxt(ind[0]);
    707                                 std::cout << *(CPPAD_GET_PAR(ind[1]));
     535                        {       CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_text() );
     536                                std::cout << Rec->GetTxt(arg[0]);
     537                                std::cout << *(CPPAD_GET_PAR(arg[1]));
    708538                        }
    709539                        break;
     
    711541
    712542                        case PrivOp:
    713                         n_var = 0;
    714                         n_ind = 2;
     543                        n_res = 0;
     544                        n_arg = 2;
    715545                        if( print )
    716                         {       CPPAD_ASSERT_UNKNOWN( ind[0] < Rec->num_rec_text() );
    717                                 CPPAD_ASSERT_UNKNOWN( ind[1] < i_var );
    718 
    719                                 X      = Taylor + ind[1] * J;
    720                                 std::cout << Rec->GetTxt(ind[0]);
     546                        {       CPPAD_ASSERT_UNKNOWN( arg[0] < Rec->num_rec_text() );
     547                                CPPAD_ASSERT_UNKNOWN( arg[1] < i_var );
     548
     549                                X      = Taylor + arg[1] * J;
     550                                std::cout << Rec->GetTxt(arg[0]);
    721551                                std::cout << X[0];
    722552                        }
     
    726556                        case SinOp:
    727557                        // vari