Changeset 3301


Ignore:
Timestamp:
May 24, 2014 1:20:21 AM (6 years ago)
Author:
bradbell
Message:

merge in multiple forward direcitons from branches/forward_dir

Location:
trunk
Files:
65 edited
4 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/bin/check_svn_id.sh

    r3218 r3301  
    3030        sed \
    3131                -e '/\/build\//d'  \
    32                 -e '/makefile\.in/d'  \
    3332                -e '/config\.h\.in/d' \
    3433                -e '/\/junk\./d' \
     34                -e '/makefile\.in/d'  \
     35                -e '/\/new\//d'  \
    3536                -e '/\/temp\./d'
    3637`
  • trunk/bin/svn_merge.sh

    r3224 r3301  
    1111# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1212# -----------------------------------------------------------------------------
    13 if [ ! -e "bin/svn_merge.sh" ]
     13if [ "$0" != "bin/svn_merge.sh" ]
    1414then
    1515        echo "bin/svn_merge.sh: must be executed from its parent directory"
     
    1717fi
    1818# -----------------------------------------------------------------------------
    19 #
    2019# Merge the changes that occurred in from_branch into the current directory
    2120#
     21# backup this file (incase it gets overwritten by merge)
     22cp bin/svn_merge.sh bin/svn_merge.sh.$$
     23#
     24# make sure current direction is up to date
     25svn update
     26#
    2227# dry_run='--dry-run'
     28# dry_run=''
    2329dry_run=''
    2430#
    25 # accept='-accept theirs-full'
    26 accept=''
    27 #
    28 # script to help in execution of svn merge command
     31# accept='--accept theirs-full'
     32# accept=''
     33accept='--accept theirs-full'
    2934#
    3035# Location of the repository
     
    3237#
    3338# Name of the directory where the changes have been committed
    34 from_branch='branches/mul_dir'
     39from_branch='branches/forward_dir'
    3540#
    3641# Version of the repository corresponding to from_branch just before changes
    37 Start=3175
     42Start=3219
    3843#
    3944# Version of the repository corresponding to from_branch after the changes
    40 End=3213
     45End=3300
    4146#
    4247# the svn merge command
    4348cmd="svn merge $accept $dry_run -r $Start:$End $repository/$from_branch"
    4449echo "$cmd"
    45 $cmd
     50eval $cmd
     51#
     52# restore original version of this file
     53mv bin/svn_merge.sh.$$ bin/svn_merge.sh
     54#
     55# get the current status
     56echo "svn status > svn_merge.log"
     57svn status > svn_merge.log
  • trunk/cppad/local/abs_op.hpp

    r3232 r3301  
    3737        size_t i_z         ,
    3838        size_t i_x         ,
    39         size_t nc_taylor   ,
     39        size_t cap_order   ,
    4040        Base*  taylor      )
    4141{
     
    4444        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
    4545        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    46         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     46        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4747        CPPAD_ASSERT_UNKNOWN( p <= q );
    4848
    4949        // Taylor coefficients corresponding to argument and result
    50         Base* x = taylor + i_x * nc_taylor;
    51         Base* z = taylor + i_z * nc_taylor;
     50        Base* x = taylor + i_x * cap_order;
     51        Base* z = taylor + i_z * cap_order;
    5252
    5353        for(size_t j = p; j <= q; j++)
    5454                z[j] = sign(x[0]) * x[j];
     55}
     56
     57/*!
     58Multiple directions forward mode Taylor coefficient for op = AbsOp.
     59
     60The C++ source code corresponding to this operation is
     61\verbatim
     62        z = abs(x)
     63\endverbatim
     64
     65\copydetails forward_unary1_op_dir
     66*/
     67template <class Base>
     68inline void forward_abs_op_dir(
     69        size_t q           ,
     70        size_t r           ,
     71        size_t i_z         ,
     72        size_t i_x         ,
     73        size_t cap_order   ,
     74        Base*  taylor      )
     75{
     76        // check assumptions
     77        CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
     78        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
     79        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     80        CPPAD_ASSERT_UNKNOWN( 0 < q );
     81        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     82
     83        // Taylor coefficients corresponding to argument and result
     84        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     85        Base* x = taylor + i_x * num_taylor_per_var;
     86        Base* z = taylor + i_z * num_taylor_per_var;
     87
     88        size_t m = (q-1) * r + 1;
     89        for(size_t ell = 0; ell < r; ell++)
     90                z[m + ell] = sign(x[0]) * x[m + ell];
    5591}
    5692
     
    69105        size_t i_z         ,
    70106        size_t i_x         ,
    71         size_t nc_taylor   ,
     107        size_t cap_order   ,
    72108        Base*  taylor      )
    73109{
     
    77113        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
    78114        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    79         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     115        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    80116
    81117        // Taylor coefficients corresponding to argument and result
    82         Base x0 = *(taylor + i_x * nc_taylor);
    83         Base* z = taylor + i_z * nc_taylor;
     118        Base x0 = *(taylor + i_x * cap_order);
     119        Base* z = taylor + i_z * cap_order;
    84120
    85121        z[0] = abs(x0);
     
    101137        size_t      i_z          ,
    102138        size_t      i_x          ,
    103         size_t      nc_taylor    ,
     139        size_t      cap_order    ,
    104140        const Base* taylor       ,
    105141        size_t      nc_partial   ,
     
    111147        CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
    112148        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    113         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     149        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    114150        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    115151
    116152        // Taylor coefficients and partials corresponding to argument
    117         const Base* x  = taylor  + i_x * nc_taylor;
     153        const Base* x  = taylor  + i_x * cap_order;
    118154        Base* px       = partial + i_x * nc_partial;
    119155
  • trunk/cppad/local/acos_op.hpp

    r3270 r3301  
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t nc_taylor   ,
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    4848{       
     
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    5252        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    53         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     53        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5454        CPPAD_ASSERT_UNKNOWN( p <= q );
    5555
    5656        // Taylor coefficients corresponding to argument and result
    57         Base* x = taylor + i_x * nc_taylor;
    58         Base* z = taylor + i_z * nc_taylor;
    59         Base* b = z      -       nc_taylor;  // called y in documentation
     57        Base* x = taylor + i_x * cap_order;
     58        Base* z = taylor + i_z * cap_order;
     59        Base* b = z      -       cap_order;  // called y in documentation
    6060
    6161        size_t k;
     
    8787        }
    8888}
     89/*!
     90Multiple directions forward mode Taylor coefficient for op = AcosOp.
     91
     92The C++ source code corresponding to this operation is
     93\verbatim
     94        z = acos(x)
     95\endverbatim
     96The auxillary result is
     97\verbatim
     98        y = sqrt(1 - x * x)
     99\endverbatim
     100The value of y, and its derivatives, are computed along with the value
     101and derivatives of z.
     102
     103\copydetails forward_unary2_op_dir
     104*/
     105template <class Base>
     106inline void forward_acos_op_dir(
     107        size_t q           ,
     108        size_t r           ,
     109        size_t i_z         ,
     110        size_t i_x         ,
     111        size_t cap_order   ,
     112        Base*  taylor      )
     113{       
     114        // check assumptions
     115        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     116        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
     117        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
     118        CPPAD_ASSERT_UNKNOWN( 0 < q );
     119        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     120
     121        // Taylor coefficients corresponding to argument and result
     122        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     123        Base* x = taylor + i_x * num_taylor_per_var;
     124        Base* z = taylor + i_z * num_taylor_per_var;
     125        Base* b = z - num_taylor_per_var;  // called y in documentation
     126
     127        size_t k, ell;
     128        size_t m = (q-1) * r + 1;
     129        for(ell = 0; ell < r; ell ++)
     130        {       Base uq = - 2.0 * x[m + ell] * x[0];
     131                for(k = 1; k < q; k++)
     132                        uq -= x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
     133                b[m+ell] = Base(0);
     134                z[m+ell] = Base(0);
     135                for(k = 1; k < q; k++)
     136                {       b[m+ell] += Base(k) * b[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
     137                        z[m+ell] += Base(k) * z[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
     138                }
     139                b[m+ell] =  ( uq / Base(2) - b[m+ell] / Base(q) ) / b[0];
     140                z[m+ell] = -( x[m+ell]     + z[m+ell] / Base(q) ) / b[0];
     141        }
     142}
    89143
    90144/*!
     
    107161        size_t i_z         ,
    108162        size_t i_x         ,
    109         size_t nc_taylor   ,
     163        size_t cap_order   ,
    110164        Base*  taylor      )
    111165{
     
    114168        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    115169        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    116         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     170        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    117171
    118172        // Taylor coefficients corresponding to argument and result
    119         Base* x = taylor + i_x * nc_taylor;
    120         Base* z = taylor + i_z * nc_taylor;
    121         Base* b = z      -       nc_taylor; // called y in documentation
     173        Base* x = taylor + i_x * cap_order;
     174        Base* z = taylor + i_z * cap_order;
     175        Base* b = z      -       cap_order; // called y in documentation
    122176
    123177        z[0] = acos( x[0] );
     
    145199        size_t      i_z          ,
    146200        size_t      i_x          ,
    147         size_t      nc_taylor    ,
     201        size_t      cap_order    ,
    148202        const Base* taylor       ,
    149203        size_t      nc_partial   ,
     
    154208        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
    155209        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    156         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     210        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    157211        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    158212
    159213        // Taylor coefficients and partials corresponding to argument
    160         const Base* x  = taylor  + i_x * nc_taylor;
     214        const Base* x  = taylor  + i_x * cap_order;
    161215        Base* px       = partial + i_x * nc_partial;
    162216
    163217        // Taylor coefficients and partials corresponding to first result
    164         const Base* z  = taylor  + i_z * nc_taylor;
     218        const Base* z  = taylor  + i_z * cap_order;
    165219        Base* pz       = partial + i_z * nc_partial;
    166220
    167221        // Taylor coefficients and partials corresponding to auxillary result
    168         const Base* b  = z  - nc_taylor; // called y in documentation
     222        const Base* b  = z  - cap_order; // called y in documentation
    169223        Base* pb       = pz - nc_partial;
    170224
  • trunk/cppad/local/ad_fun.hpp

    r3232 r3301  
    8989        size_t cap_order_taylor_;
    9090
     91        /// number of directions stored in taylor_
     92        size_t num_direction_taylor_;
     93
    9194        /// number of variables in the recording (play_)
    9295        size_t num_var_tape_;
     
    273276        void Dependent(const ADvector &x, const ADvector &y);
    274277
    275         /// forward mode sweep
     278        /// forward mode user API, one order multiple directions.
     279        template <typename VectorBase>
     280        VectorBase Forward(size_t q, size_t r, const VectorBase& x);
     281
     282        /// forward mode user API, multiple directions one order.
    276283        template <typename VectorBase>
    277284        VectorBase Forward(size_t q,
     
    349356        {       return num_order_taylor_; }
    350357
     358        /// number taylor coefficient directions calculated
     359        size_t size_direction(void) const
     360        {       return num_direction_taylor_; }
     361
    351362        /// number of characters in the operation sequence
    352363        size_t size_text(void) const
     
    361372        {       return play_.num_vec_ind_rec(); }
    362373
     374        /// set number of orders currently allocated (user API)
     375        void capacity_order(size_t c);
     376
    363377        /// set number of orders and directions currently allocated
    364         void capacity_order(size_t c);   
     378        void capacity_order(size_t c, size_t r);   
    365379
    366380        /// number of variables in conditional expressions that can be skipped
     
    532546# include <cppad/local/forward0sweep.hpp>
    533547# include <cppad/local/forward1sweep.hpp>
     548# include <cppad/local/forward2sweep.hpp>
    534549# include <cppad/local/reverse_sweep.hpp>
    535550# include <cppad/local/for_jac_sweep.hpp>
  • trunk/cppad/local/add_op.hpp

    r3232 r3301  
    4242        const addr_t* arg         ,
    4343        const Base*   parameter   ,
    44         size_t        nc_taylor   ,
     44        size_t        cap_order   ,
    4545        Base*         taylor      )
    4646{
     
    5050        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    5151        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    52         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     52        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5353        CPPAD_ASSERT_UNKNOWN( p <= q  );
    5454
    5555        // Taylor coefficients corresponding to arguments and result
    56         Base* x = taylor + arg[0] * nc_taylor;
    57         Base* y = taylor + arg[1] * nc_taylor;
    58         Base* z = taylor + i_z    * nc_taylor;
     56        Base* x = taylor + arg[0] * cap_order;
     57        Base* y = taylor + arg[1] * cap_order;
     58        Base* z = taylor + i_z    * cap_order;
    5959
    6060        for(size_t j = p; j <= q; j++)
    6161                z[j] = x[j] + y[j];
    6262}
    63 
    64 /*!
    65 Compute zero order forward mode Taylor coefficients for result of op = AddvvOp.
     63/*!
     64Multiple directions forward mode Taylor coefficients for op = AddvvOp.
    6665
    6766The C++ source code corresponding to this operation is
     
    7372and the argument \a parameter is not used.
    7473
    75 \copydetails forward_binary_op_0
    76 */
    77 
    78 template <class Base>
    79 inline void forward_addvv_op_0(
    80         size_t        i_z         ,
    81         const addr_t* arg         ,
    82         const Base*   parameter   ,
    83         size_t        nc_taylor   ,
     74\copydetails forward_binary_op_dir
     75*/
     76
     77template <class Base>
     78inline void forward_addvv_op_dir(
     79        size_t        q           ,
     80        size_t        r           ,
     81        size_t        i_z         ,
     82        const addr_t* arg         ,
     83        const Base*   parameter   ,
     84        size_t        cap_order   ,
    8485        Base*         taylor      )
    8586{
     
    8990        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    9091        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    91 
    92         // Taylor coefficients corresponding to arguments and result
    93         Base* x = taylor + arg[0] * nc_taylor;
    94         Base* y = taylor + arg[1] * nc_taylor;
    95         Base* z = taylor + i_z    * nc_taylor;
    96 
    97         z[0] = x[0] + y[0];
    98 }
    99 
    100 /*!
    101 Compute reverse mode partial derivatives for result of op = AddvvOp.
     92        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     93        CPPAD_ASSERT_UNKNOWN( 0 < q  );
     94
     95        // Taylor coefficients corresponding to arguments and result
     96        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     97        Base* x = taylor + arg[0] * num_taylor_per_var;
     98        Base* y = taylor + arg[1] * num_taylor_per_var;
     99        Base* z = taylor +    i_z * num_taylor_per_var;
     100
     101        size_t m = (q-1)*r + 1 ;
     102        for(size_t ell = 0; ell < r; ell++)
     103                z[m+ell] = x[m+ell] + y[m+ell];
     104}
     105
     106/*!
     107Compute zero order forward mode Taylor coefficients for result of op = AddvvOp.
    102108
    103109The C++ source code corresponding to this operation is
     
    109115and the argument \a parameter is not used.
    110116
     117\copydetails forward_binary_op_0
     118*/
     119
     120template <class Base>
     121inline void forward_addvv_op_0(
     122        size_t        i_z         ,
     123        const addr_t* arg         ,
     124        const Base*   parameter   ,
     125        size_t        cap_order   ,
     126        Base*         taylor      )
     127{
     128        // check assumptions
     129        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
     130        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
     131        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
     132        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     133
     134        // Taylor coefficients corresponding to arguments and result
     135        Base* x = taylor + arg[0] * cap_order;
     136        Base* y = taylor + arg[1] * cap_order;
     137        Base* z = taylor + i_z    * cap_order;
     138
     139        z[0] = x[0] + y[0];
     140}
     141
     142/*!
     143Compute reverse mode partial derivatives for result of op = AddvvOp.
     144
     145The C++ source code corresponding to this operation is
     146\verbatim
     147        z = x + y
     148\endverbatim
     149In the documentation below,
     150this operations is for the case where both x and y are variables
     151and the argument \a parameter is not used.
     152
    111153\copydetails reverse_binary_op
    112154*/
     
    118160        const addr_t* arg         ,
    119161        const Base*   parameter   ,
    120         size_t        nc_taylor   ,
     162        size_t        cap_order   ,
    121163        const Base*   taylor      ,
    122164        size_t        nc_partial  ,
     
    128170        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    129171        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    130         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     172        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    131173        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    132174
     
    158200\copydetails forward_binary_op
    159201*/
    160 
    161202template <class Base>
    162203inline void forward_addpv_op(
     
    166207        const addr_t* arg         ,
    167208        const Base*   parameter   ,
    168         size_t        nc_taylor   ,
     209        size_t        cap_order   ,
    169210        Base*         taylor      )
    170211{
     
    173214        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
    174215        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    175         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     216        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    176217        CPPAD_ASSERT_UNKNOWN( p <= q );
    177218
    178219        // Taylor coefficients corresponding to arguments and result
    179         Base* y = taylor + arg[1] * nc_taylor;
    180         Base* z = taylor + i_z    * nc_taylor;
     220        Base* y = taylor + arg[1] * cap_order;
     221        Base* z = taylor + i_z    * cap_order;
    181222
    182223        if( p == 0 )
     
    190231}
    191232/*!
    192 Compute zero order forward mode Taylor coefficient for result of op = AddpvOp.
     233Multiple directions forward mode Taylor coefficients for op = AddpvOp.
    193234
    194235The C++ source code corresponding to this operation is
     
    199240this operations is for the case where x is a parameter and y is a variable.
    200241
    201 \copydetails forward_binary_op_0
    202 */
    203 
    204 template <class Base>
    205 inline void forward_addpv_op_0(
    206         size_t        i_z         ,
    207         const addr_t* arg         ,
    208         const Base*   parameter   ,
    209         size_t        nc_taylor   ,
     242\copydetails forward_binary_op_dir
     243*/
     244template <class Base>
     245inline void forward_addpv_op_dir(
     246        size_t        q           ,
     247        size_t        r           ,
     248        size_t        i_z         ,
     249        const addr_t* arg         ,
     250        const Base*   parameter   ,
     251        size_t        cap_order   ,
    210252        Base*         taylor      )
    211253{
     
    214256        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
    215257        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     258        CPPAD_ASSERT_UNKNOWN( 0 < q );
     259        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     260
     261        // Taylor coefficients corresponding to arguments and result
     262        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     263        size_t m                  = (q-1) * r + 1;
     264        Base* y = taylor + arg[1] * num_taylor_per_var + m;
     265        Base* z = taylor + i_z    * num_taylor_per_var + m;
     266
     267        for(size_t ell = 0; ell < r; ell++)
     268                z[ell] = y[ell];
     269}
     270/*!
     271Compute zero order forward mode Taylor coefficient for result of op = AddpvOp.
     272
     273The C++ source code corresponding to this operation is
     274\verbatim
     275        z = x + y
     276\endverbatim
     277In the documentation below,
     278this operations is for the case where x is a parameter and y is a variable.
     279
     280\copydetails forward_binary_op_0
     281*/
     282
     283template <class Base>
     284inline void forward_addpv_op_0(
     285        size_t        i_z         ,
     286        const addr_t* arg         ,
     287        const Base*   parameter   ,
     288        size_t        cap_order   ,
     289        Base*         taylor      )
     290{
     291        // check assumptions
     292        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
     293        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
     294        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    216295
    217296        // Paraemter value
     
    219298
    220299        // Taylor coefficients corresponding to arguments and result
    221         Base* y = taylor + arg[1] * nc_taylor;
    222         Base* z = taylor + i_z    * nc_taylor;
     300        Base* y = taylor + arg[1] * cap_order;
     301        Base* z = taylor + i_z    * cap_order;
    223302
    224303        z[0] = x + y[0];
     
    244323        const addr_t* arg         ,
    245324        const Base*   parameter   ,
    246         size_t        nc_taylor   ,
     325        size_t        cap_order   ,
    247326        const Base*   taylor      ,
    248327        size_t        nc_partial  ,
     
    253332        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
    254333        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    255         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     334        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    256335        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    257336
  • trunk/cppad/local/asin_op.hpp

    r3270 r3301  
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t nc_taylor   ,
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    4848{       
     
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    5252        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    53         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     53        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5454        CPPAD_ASSERT_UNKNOWN( p <= q );
    5555
    5656        // Taylor coefficients corresponding to argument and result
    57         Base* x = taylor + i_x * nc_taylor;
    58         Base* z = taylor + i_z * nc_taylor;
    59         Base* b = z      -       nc_taylor;  // called y in documentation
     57        Base* x = taylor + i_x * cap_order;
     58        Base* z = taylor + i_z * cap_order;
     59        Base* b = z      -       cap_order;  // called y in documentation
    6060
    6161        size_t k;
     
    8787        }
    8888}
     89/*!
     90Multiple directions forward mode Taylor coefficient for op = AsinOp.
     91
     92The C++ source code corresponding to this operation is
     93\verbatim
     94        z = asin(x)
     95\endverbatim
     96The auxillary result is
     97\verbatim
     98        y = sqrt(1 - x * x)
     99\endverbatim
     100The value of y, and its derivatives, are computed along with the value
     101and derivatives of z.
     102
     103\copydetails forward_unary2_op_dir
     104*/
     105template <class Base>
     106inline void forward_asin_op_dir(
     107        size_t q           ,
     108        size_t r           ,
     109        size_t i_z         ,
     110        size_t i_x         ,
     111        size_t cap_order   ,
     112        Base*  taylor      )
     113{       
     114        // check assumptions
     115        CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
     116        CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
     117        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
     118        CPPAD_ASSERT_UNKNOWN( 0 < q );
     119        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     120
     121        // Taylor coefficients corresponding to argument and result
     122        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     123        Base* x = taylor + i_x * num_taylor_per_var;
     124        Base* z = taylor + i_z * num_taylor_per_var;
     125        Base* b = z - num_taylor_per_var;  // called y in documentation
     126
     127        size_t k, ell;
     128        size_t m = (q-1) * r + 1;
     129        for(ell = 0; ell < r; ell ++)
     130        {       Base uq = - 2.0 * x[m + ell] * x[0];
     131                for(k = 1; k < q; k++)
     132                        uq -= x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
     133                b[m+ell] = Base(0);
     134                z[m+ell] = Base(0);
     135                for(k = 1; k < q; k++)
     136                {       b[m+ell] += Base(k) * b[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
     137                        z[m+ell] += Base(k) * z[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
     138                }
     139                b[m+ell] = ( uq / Base(2) - b[m+ell] / Base(q) ) / b[0];
     140                z[m+ell] = ( x[m+ell]     - z[m+ell] / Base(q) ) / b[0];
     141        }
     142}
    89143
    90144/*!
     
    107161        size_t i_z         ,
    108162        size_t i_x         ,
    109         size_t nc_taylor   ,
     163        size_t cap_order   ,
    110164        Base*  taylor      )
    111165{
     
    114168        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    115169        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    116         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     170        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    117171
    118172        // Taylor coefficients corresponding to argument and result
    119         Base* x = taylor + i_x * nc_taylor;
    120         Base* z = taylor + i_z * nc_taylor;
    121         Base* b = z      -       nc_taylor; // called y in documentation
     173        Base* x = taylor + i_x * cap_order;
     174        Base* z = taylor + i_z * cap_order;
     175        Base* b = z      -       cap_order; // called y in documentation
    122176
    123177        z[0] = asin( x[0] );
     
    145199        size_t      i_z          ,
    146200        size_t      i_x          ,
    147         size_t      nc_taylor    ,
     201        size_t      cap_order    ,
    148202        const Base* taylor       ,
    149203        size_t      nc_partial   ,
     
    154208        CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
    155209        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    156         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     210        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    157211        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    158212
    159213        // Taylor coefficients and partials corresponding to argument
    160         const Base* x  = taylor  + i_x * nc_taylor;
     214        const Base* x  = taylor  + i_x * cap_order;
    161215        Base* px       = partial + i_x * nc_partial;
    162216
    163217        // Taylor coefficients and partials corresponding to first result
    164         const Base* z  = taylor  + i_z * nc_taylor;
     218        const Base* z  = taylor  + i_z * cap_order;
    165219        Base* pz       = partial + i_z * nc_partial;
    166220
    167221        // Taylor coefficients and partials corresponding to auxillary result
    168         const Base* b  = z  - nc_taylor; // called y in documentation
     222        const Base* b  = z  - cap_order; // called y in documentation
    169223        Base* pb       = pz - nc_partial;
    170224
  • trunk/cppad/local/atan_op.hpp

    r3232 r3301  
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t nc_taylor   ,
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    4848{       
     
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    5252        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    53         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     53        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5454        CPPAD_ASSERT_UNKNOWN( p <= q );
    5555
    5656        // Taylor coefficients corresponding to argument and result
    57         Base* x = taylor + i_x * nc_taylor;
    58         Base* z = taylor + i_z * nc_taylor;
    59         Base* b = z      -       nc_taylor;  // called y in documentation
     57        Base* x = taylor + i_x * cap_order;
     58        Base* z = taylor + i_z * cap_order;
     59        Base* b = z      -       cap_order;  // called y in documentation
    6060
    6161        size_t k;
     
    8080
    8181/*!
     82Multiple direction Taylor coefficient for op = AtanOp.
     83
     84The C++ source code corresponding to this operation is
     85\verbatim
     86        z = atan(x)
     87\endverbatim
     88The auxillary result is
     89\verbatim
     90        y = 1 + x * x
     91\endverbatim
     92The value of y, and its derivatives, are computed along with the value
     93and derivatives of z.
     94
     95\copydetails forward_unary2_op_dir
     96*/
     97template <class Base>
     98inline void forward_atan_op_dir(
     99        size_t q           ,
     100        size_t r           ,
     101        size_t i_z         ,
     102        size_t i_x         ,
     103        size_t cap_order   ,
     104        Base*  taylor      )
     105{       
     106        // check assumptions
     107        CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
     108        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
     109        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
     110        CPPAD_ASSERT_UNKNOWN( 0 < q );
     111        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     112
     113        // Taylor coefficients corresponding to argument and result
     114        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     115        Base* x = taylor + i_x * num_taylor_per_var;
     116        Base* z = taylor + i_z * num_taylor_per_var;
     117        Base* b = z      -       num_taylor_per_var; // called y in documentation
     118
     119        size_t m = (q-1) * r + 1;
     120        for(size_t ell = 0; ell < r; ell++)
     121        {       b[m+ell] = Base(2) * x[m+ell] * x[0];
     122                z[m+ell] = Base(q) * x[m+ell];
     123                for(size_t k = 1; k < q; k++)
     124                {       b[m+ell] += x[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
     125                        z[m+ell] -= Base(k) * z[(k-1)*r+1+ell] * b[(q-k-1)*r+1+ell];
     126                }
     127                z[m+ell] /= ( Base(q) * b[0] );
     128        }
     129}
     130
     131/*!
    82132Zero order forward mode Taylor coefficient for result of op = AtanOp.
    83133
     
    98148        size_t i_z         ,
    99149        size_t i_x         ,
    100         size_t nc_taylor   ,
     150        size_t cap_order   ,
    101151        Base*  taylor      )
    102152{
     
    105155        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    106156        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    107         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     157        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    108158
    109159        // Taylor coefficients corresponding to argument and result
    110         Base* x = taylor + i_x * nc_taylor;
    111         Base* z = taylor + i_z * nc_taylor;
    112         Base* b = z      -       nc_taylor; // called y in documentation
     160        Base* x = taylor + i_x * cap_order;
     161        Base* z = taylor + i_z * cap_order;
     162        Base* b = z      -       cap_order; // called y in documentation
    113163
    114164        z[0] = atan( x[0] );
     
    136186        size_t      i_z          ,
    137187        size_t      i_x          ,
    138         size_t      nc_taylor    ,
     188        size_t      cap_order    ,
    139189        const Base* taylor       ,
    140190        size_t      nc_partial   ,
     
    145195        CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
    146196        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    147         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     197        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    148198        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    149199
    150200        // Taylor coefficients and partials corresponding to argument
    151         const Base* x  = taylor  + i_x * nc_taylor;
     201        const Base* x  = taylor  + i_x * cap_order;
    152202        Base* px       = partial + i_x * nc_partial;
    153203
    154204        // Taylor coefficients and partials corresponding to first result
    155         const Base* z  = taylor  + i_z * nc_taylor;
     205        const Base* z  = taylor  + i_z * cap_order;
    156206        Base* pz       = partial + i_z * nc_partial;
    157207
    158208        // Taylor coefficients and partials corresponding to auxillary result
    159         const Base* b  = z  - nc_taylor; // called y in documentation
     209        const Base* b  = z  - cap_order; // called y in documentation
    160210        Base* pb       = pz - nc_partial;
    161211
  • trunk/cppad/local/capacity_order.hpp

    r3232 r3301  
    127127
    128128/*!
    129 Control of number of orders allocated.
    130 
     129Control of number of orders and directions allocated.
    131130
    132131\tparam Base
     
    136135\param c
    137136is the number of orders to allocate memory for.
    138 If <code>c == 0</code>,
    139 the values num_order_taylor_, cap_order_taylor_, and num_direction_taylor_
     137If <code>c == 0</code> then \c r must also be zero.
     138In this case num_order_taylor_, cap_order_taylor_, and num_direction_taylor_
    140139are all set to zero.
    141140In addition, taylor_.free() is called.
     141
     142\param r
     143is the number of directions to allocate memory for.
     144If <code>c == 1</code> then \c r must also be one.
     145In all cases, it must hold that
     146<code>
     147        r == num_direction_taylor_ || num_order_taylor <= 1
     148</code>
     149Upon return, num_direction_taylor_ is equal to r.
    142150
    143151\par num_order_taylor_
     
    145153value and c. This minimum is the number of orders that are copied to the
    146154new taylor coefficient buffer.
     155
     156\par num_direction_taylor_
     157The output value of num_direction_taylor_ is equal to \c r.
    147158*/
    148159
    149160template <typename Base>
    150 void ADFun<Base>::capacity_order(size_t c)
     161void ADFun<Base>::capacity_order(size_t c, size_t r)
    151162{       // temporary indices
    152         size_t i, k;
    153 
    154         if(c == cap_order_taylor_ )
     163        size_t i, k, ell;
     164
     165        if( (c == cap_order_taylor_) & (r == num_direction_taylor_) )
    155166                return;
    156167
    157168        if( c == 0 )
    158         {       taylor_.free();
     169        {       CPPAD_ASSERT_UNKNOWN( r == 0 );
     170                taylor_.free();
    159171                num_order_taylor_     = 0;
    160172                cap_order_taylor_     = 0;
     173                num_direction_taylor_ = r;
    161174                return;
    162175        }
     176        CPPAD_ASSERT_UNKNOWN(r==num_direction_taylor_ || num_order_taylor_<=1);
    163177       
    164         // Allocate new matrix with requested number of columns
    165         size_t new_len   = num_var_tape_  * c;
     178        // Allocate new taylor with requested number of orders and directions
     179        size_t new_len   = ( (c-1)*r + 1 ) * num_var_tape_;
    166180        pod_vector<Base> new_taylor;
    167181        new_taylor.extend(new_len);
    168 
    169182
    170183        // number of orders to copy
     
    175188                size_t C = cap_order_taylor_;
    176189
     190                // old number of directions
     191                size_t R = num_direction_taylor_;
     192
    177193                // copy the old data into the new matrix
     194                CPPAD_ASSERT_UNKNOWN( p == 1 || r == R );
    178195                for(i = 0; i < num_var_tape_; i++)
    179                 {       for(k = 0; k < p; k++)
    180                                 new_taylor[ c*i + k] = taylor_[ C*i + k];
     196                {       // copy zero order
     197                        size_t old_index = ((C-1) * R + 1) * i + 0;
     198                        size_t new_index = ((c-1) * r + 1) * i + 0;
     199                        new_taylor[ new_index ] = taylor_[ old_index ];
     200                        // copy higher orders
     201                        for(k = 1; k < p; k++)
     202                        {       for(ell = 0; ell < R; ell++)
     203                                {       old_index = ((C-1) * R + 1) * i + (k-1) * R + ell + 1;
     204                                        new_index = ((c-1) * r + 1) * i + (k-1) * r + ell + 1;
     205                                        new_taylor[ new_index ] = taylor_[ old_index ];
     206                                }
     207                        }
    181208                }
    182209        }
     
    184211        // replace taylor_ by new_taylor
    185212        taylor_.swap(new_taylor);
    186         cap_order_taylor_ = c;
    187         num_order_taylor_ = p;
     213        cap_order_taylor_     = c;
     214        num_order_taylor_     = p;
     215        num_direction_taylor_ = r;
    188216
    189217        // note that the destructor for new_taylor will free the old taylor memory
     
    191219}
    192220
     221/*!
     222User API control of number of orders allocated.
     223
     224\tparam Base
     225The type used during the forward mode computations; i.e., the corresponding
     226recording of operations used the type AD<Base>.
     227
     228\param c
     229is the number of orders to allocate memory for.
     230If <code>c == 0</code>,
     231num_order_taylor_, cap_order_taylor_, and num_direction_taylor_
     232are all set to zero.
     233In addition, taylor_.free() is called.
     234
     235\par num_order_taylor_
     236The output value of num_order_taylor_ is the mininumum of its input
     237value and c. This minimum is the number of orders that are copied to the
     238new taylor coefficient buffer.
     239
     240\par num_direction_taylor_
     241If \c is zero (one), \c num_direction_taylor_ is set to zero (one).
     242Otherwise, if \c num_direction_taylor_ is zero, it is set to one.
     243Othwerwise, \c num_direction_taylor_ is not modified.
     244*/
     245
     246template <typename Base>
     247void ADFun<Base>::capacity_order(size_t c)
     248{       size_t r;
     249        if( (c == 0) | (c == 1) )
     250        {       r = c;
     251                capacity_order(c, r);
     252                return;
     253        }
     254        r = num_direction_taylor_;
     255        if( r == 0 )
     256                r = 1;
     257        capacity_order(c, r);
     258        return;
     259}
     260
    193261} // END CppAD namespace
    194262       
  • trunk/cppad/local/checkpoint.hpp

    r3232 r3301  
    275275                // no longer need the Taylor coefficients in f_
    276276                // (have to reconstruct them every time)
    277                 f_.capacity_order(0);
     277                size_t c = 0;
     278                size_t r = 0;
     279                f_.capacity_order(c, r);
    278280                return ok;
    279281        }
     
    318320                // no longer need the Taylor coefficients in f_
    319321                // (have to reconstruct them every time)
    320                 f_.capacity_order(0);
     322                size_t c = 0;
     323                size_t r = 0;
     324                f_.capacity_order(c, r);
    321325                return ok;
    322326        }
  • trunk/cppad/local/comp_op.hpp

    r3232 r3301  
    8585If right is a parameter, \a parameter[ arg[3] ] is its value.
    8686
    87 \param nc_taylor
     87\param cap_order
    8888number of columns in the matrix containing the Taylor coefficients.
    8989
    9090\param taylor
    9191Matrix of Taylor coefficients.
    92 If left is a variable, \a taylor[ arg[2] * nc_taylor + 0 ] is its value.
    93 If right is a variable, \a taylor[ arg[3] * nc_taylor + 0 ] is its value.
     92If left is a variable, \a taylor[ arg[2] * cap_order + 0 ] is its value.
     93If right is a variable, \a taylor[ arg[3] * cap_order + 0 ] is its value.
    9494
    9595
     
    109109        size_t         num_par     ,
    110110        const Base*    parameter   ,
    111         size_t         nc_taylor   ,
     111        size_t         cap_order   ,
    112112        Base*          taylor      )
    113113{       bool result;
     
    125125        // value of left operand for this forward sweep
    126126        if( arg[1] & 2 )
    127                 left = taylor[ arg[2] * nc_taylor + 0 ];
     127                left = taylor[ arg[2] * cap_order + 0 ];
    128128        else
    129129        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
     
    133133        // value of right operand for this forward sweep.
    134134        if( arg[1] & 4 )
    135                 right = taylor[ arg[3] * nc_taylor + 0 ];
     135                right = taylor[ arg[3] * cap_order + 0 ];
    136136        else
    137137        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
  • trunk/cppad/local/cond_op.hpp

    r3232 r3301  
    8686if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
    8787
    88 \param nc_taylor
     88\param cap_order
    8989number of columns in the matrix containing the Taylor coefficients.
    9090
     
    104104        size_t         num_par     ,
    105105        const Base*    parameter   ,
    106         size_t         nc_taylor   )
     106        size_t         cap_order   )
    107107{       // This routine is only for documentation, it should never be used
    108108        CPPAD_ASSERT_UNKNOWN( false );
     
    256256if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
    257257
    258 \param nc_taylor
     258\param cap_order
    259259number of columns in the matrix containing the Taylor coefficients.
    260260
     
    278278For j = 0, 1, 2, 3 and k = 0 , ... , q,
    279279if y_j is a variable then
    280 <code>taylor [ arg[2+j] * nc_taylor + k ]</code>
     280<code>taylor [ arg[2+j] * cap_order + k ]</code>
    281281is the k-th order Taylor coefficient corresponding to y_j.
    282282\n
    283 \b Input: <code>taylor [ i_z * nc_taylor + k ]</code>
     283\b Input: <code>taylor [ i_z * cap_order + k ]</code>
    284284for k = 0 , ... , p-1,
    285285is the k-th order Taylor coefficient corresponding to z.
    286286\n
    287 \b Output: <code>taylor [ i_z * nc_taylor + k ]</code>
     287\b Output: <code>taylor [ i_z * cap_order + k ]</code>
    288288for k = p , ... , q,
    289289is the k-th order Taylor coefficient corresponding to z.
     
    298298        size_t         num_par     ,
    299299        const Base*    parameter   ,
    300         size_t         nc_taylor   ,
     300        size_t         cap_order   ,
    301301        Base*          taylor      )
    302302{       Base y_0, y_1, y_2, y_3;
    303303        Base zero(0);
    304         Base* z = taylor + i_z * nc_taylor;
     304        Base* z = taylor + i_z * cap_order;
    305305
    306306        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
     
    311311        if( arg[1] & 1 )
    312312        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
    313                 y_0 = taylor[ arg[2] * nc_taylor + 0 ];
     313                y_0 = taylor[ arg[2] * cap_order + 0 ];
    314314        }
    315315        else
     
    319319        if( arg[1] & 2 )
    320320        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
    321                 y_1 = taylor[ arg[3] * nc_taylor + 0 ];
     321                y_1 = taylor[ arg[3] * cap_order + 0 ];
    322322        }
    323323        else
     
    328328        {       if( arg[1] & 4 )
    329329                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
    330                         y_2 = taylor[ arg[4] * nc_taylor + 0 ];
     330                        y_2 = taylor[ arg[4] * cap_order + 0 ];
    331331                }
    332332                else
     
    336336                if( arg[1] & 8 )
    337337                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
    338                         y_3 = taylor[ arg[5] * nc_taylor + 0 ];
     338                        y_3 = taylor[ arg[5] * cap_order + 0 ];
    339339                }
    340340                else
     
    354354        {       if( arg[1] & 4 )
    355355                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
    356                         y_2 = taylor[ arg[4] * nc_taylor + d];
     356                        y_2 = taylor[ arg[4] * cap_order + d];
    357357                }
    358358                else    y_2 = zero;
    359359                if( arg[1] & 8 )
    360360                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
    361                         y_3 = taylor[ arg[5] * nc_taylor + d];
     361                        y_3 = taylor[ arg[5] * cap_order + d];
    362362                }
    363363                else    y_3 = zero;
     
    374374
    375375/*!
    376 Compute zero order forward mode Taylor coefficients for op = CExpOp.
     376Multiple directions forward mode Taylor coefficients for op = CExpOp.
    377377
    378378<!-- replace conditional_exp_op -->
     
    440440if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
    441441
    442 \param nc_taylor
     442\param cap_order
    443443number of columns in the matrix containing the Taylor coefficients.
    444444
     
    452452<!-- end conditional_exp_op -->
    453453
     454\param q
     455is order of the Taylor coefficient of z that we are computing.
     456
     457\param r
     458is the number of Taylor coefficient directions that we are computing.
     459
     460\par tpv
     461We use the notation
     462<code>tpv = (cap_order-1) * r + 1</code>
     463which is the number of Taylor coefficients per variable
     464
     465\param taylor
     466\b Input:
     467For j = 0, 1, 2, 3, k = 1, ..., q,
     468if y_j is a variable then
     469<code>taylor [ arg[2+j] * tpv + 0 ]</code>
     470is the zero order Taylor coefficient corresponding to y_j and
     471<code>taylor [ arg[2+j] * tpv + (k-1)*r+1+ell</code> is its
     472k-th order Taylor coefficient in the ell-th direction.
     473\n
     474\b Input:
     475For j = 0, 1, 2, 3, k = 1, ..., q-1,
     476<code>taylor [ i_z * tpv + 0 ]</code>
     477is the zero order Taylor coefficient corresponding to z and
     478<code>taylor [ i_z * tpv + (k-1)*r+1+ell</code> is its
     479k-th order Taylor coefficient in the ell-th direction.
     480\n
     481\b Output: <code>taylor [ i_z * tpv + (q-1)*r+1+ell ]</code>
     482is the q-th order Taylor coefficient corresponding to z
     483in the ell-th direction.
     484*/
     485template <class Base>
     486inline void forward_cond_op_dir(
     487        size_t         q           ,
     488        size_t         r           ,
     489        size_t         i_z         ,
     490        const addr_t*  arg         ,
     491        size_t         num_par     ,
     492        const Base*    parameter   ,
     493        size_t         cap_order   ,
     494        Base*          taylor      )
     495{       Base y_0, y_1, y_2, y_3;
     496        Base zero(0);
     497        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     498        Base* z = taylor + i_z * num_taylor_per_var;
     499
     500        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
     501        CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
     502        CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
     503        CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
     504        CPPAD_ASSERT_UNKNOWN( 0 < q );
     505        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     506
     507        if( arg[1] & 1 )
     508        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
     509                y_0 = taylor[ arg[2] * num_taylor_per_var + 0 ];
     510        }
     511        else
     512        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
     513                y_0 = parameter[ arg[2] ];
     514        }
     515        if( arg[1] & 2 )
     516        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
     517                y_1 = taylor[ arg[3] * num_taylor_per_var + 0 ];
     518        }
     519        else
     520        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
     521                y_1 = parameter[ arg[3] ];
     522        }
     523        size_t m = (q-1) * r + 1;
     524        for(size_t ell = 0; ell < r; ell++)
     525        {       if( arg[1] & 4 )
     526                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
     527                        y_2 = taylor[ arg[4] * num_taylor_per_var + m + ell];
     528                }
     529                else    y_2 = zero;
     530                if( arg[1] & 8 )
     531                {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
     532                        y_3 = taylor[ arg[5] * num_taylor_per_var + m + ell];
     533                }
     534                else    y_3 = zero;
     535                z[m+ell] = CondExpOp(
     536                        CompareOp( arg[0] ),
     537                        y_0,
     538                        y_1,
     539                        y_2,
     540                        y_3
     541                );
     542        }
     543        return;
     544}
     545
     546/*!
     547Compute zero order forward mode Taylor coefficients for op = CExpOp.
     548
     549<!-- replace conditional_exp_op -->
     550The C++ source code coresponding to this operation is
     551\verbatim
     552        z = CondExpRel(y_0, y_1, y_2, y_3)
     553\endverbatim
     554where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
     555
     556\tparam Base
     557base type for the operator; i.e., this operation was recorded
     558using AD< \a Base > and computations by this routine are done using type
     559\a Base.
     560
     561\param i_z
     562is the AD variable index corresponding to the variable z.
     563
     564\param arg
     565\n
     566\a arg[0]
     567is static cast to size_t from the enum type
     568\verbatim
     569        enum CompareOp {
     570                CompareLt,
     571                CompareLe,
     572                CompareEq,
     573                CompareGe,
     574                CompareGt,
     575                CompareNe
     576        }
     577\endverbatim
     578for this operation.
     579Note that arg[0] cannot be equal to CompareNe.
     580\n
     581\n
     582\a arg[1] & 1
     583\n
     584If this is zero, y_0 is a parameter. Otherwise it is a variable.
     585\n
     586\n
     587\a arg[1] & 2
     588\n
     589If this is zero, y_1 is a parameter. Otherwise it is a variable.
     590\n
     591\n
     592\a arg[1] & 4
     593\n
     594If this is zero, y_2 is a parameter. Otherwise it is a variable.
     595\n
     596\n
     597\a arg[1] & 8
     598\n
     599If this is zero, y_3 is a parameter. Otherwise it is a variable.
     600\n
     601\n
     602\a arg[2 + j ] for j = 0, 1, 2, 3
     603\n
     604is the index corresponding to y_j.
     605
     606\param num_par
     607is the total number of values in the vector \a parameter.
     608
     609\param parameter
     610For j = 0, 1, 2, 3,
     611if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
     612
     613\param cap_order
     614number of columns in the matrix containing the Taylor coefficients.
     615
     616\par Checked Assertions
     617\li NumArg(CExpOp) == 6
     618\li NumRes(CExpOp) == 1
     619\li arg[0] < static_cast<size_t> ( CompareNe )
     620\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
     621\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
     622\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
     623<!-- end conditional_exp_op -->
     624
    454625\param taylor
    455626\b Input:
    456627For j = 0, 1, 2, 3,
    457628if y_j is a variable then
    458 \a taylor [ \a arg[2+j] * nc_taylor + 0 ]
     629\a taylor [ \a arg[2+j] * cap_order + 0 ]
    459630is the zero order Taylor coefficient corresponding to y_j.
    460631\n
    461 \b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
     632\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
    462633is the zero order Taylor coefficient corresponding to z.
    463634*/
     
    468639        size_t         num_par     ,
    469640        const Base*    parameter   ,
    470         size_t         nc_taylor   ,
     641        size_t         cap_order   ,
    471642        Base*          taylor      )
    472643{       Base y_0, y_1, y_2, y_3;
     
    480651        if( arg[1] & 1 )
    481652        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
    482                 y_0 = taylor[ arg[2] * nc_taylor + 0 ];
     653                y_0 = taylor[ arg[2] * cap_order + 0 ];
    483654        }
    484655        else
     
    488659        if( arg[1] & 2 )
    489660        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
    490                 y_1 = taylor[ arg[3] * nc_taylor + 0 ];
     661                y_1 = taylor[ arg[3] * cap_order + 0 ];
    491662        }
    492663        else
     
    496667        if( arg[1] & 4 )
    497668        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
    498                 y_2 = taylor[ arg[4] * nc_taylor + 0 ];
     669                y_2 = taylor[ arg[4] * cap_order + 0 ];
    499670        }
    500671        else
     
    504675        if( arg[1] & 8 )
    505676        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
    506                 y_3 = taylor[ arg[5] * nc_taylor + 0 ];
     677                y_3 = taylor[ arg[5] * cap_order + 0 ];
    507678        }
    508679        else
     
    510681                y_3 = parameter[ arg[5] ];
    511682        }
    512         z = taylor + i_z * nc_taylor;
     683        z = taylor + i_z * cap_order;
    513684        z[0] = CondExpOp(
    514685                CompareOp( arg[0] ),
     
    596767if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
    597768
    598 \param nc_taylor
     769\param cap_order
    599770number of columns in the matrix containing the Taylor coefficients.
    600771
     
    615786For j = 0, 1, 2, 3 and k = 0 , ... , \a d,
    616787if y_j is a variable then
    617 \a taylor [ \a arg[2+j] * nc_taylor + k ]
     788\a taylor [ \a arg[2+j] * cap_order + k ]
    618789is the k-th order Taylor coefficient corresponding to y_j.
    619790\n
    620 \a taylor [ \a i_z * \a nc_taylor + k ]
     791\a taylor [ \a i_z * \a cap_order + k ]
    621792for k = 0 , ... , \a d
    622793is the k-th order Taylor coefficient corresponding to z.
     
    633804with respect to the k-th order Taylor coefficient corresponding to y_j.
    634805\n
    635 \b Input: \a partial [ \a i_z * \a nc_taylor + k ]
     806\b Input: \a partial [ \a i_z * \a cap_order + k ]
    636807for k = 0 , ... , \a d
    637808is the partial derivative of G( z , y , x , w , u , ... )
     
    653824        size_t         num_par     ,
    654825        const Base*    parameter   ,
    655         size_t         nc_taylor   ,
     826        size_t         cap_order   ,
    656827        const Base*    taylor      ,
    657828        size_t         nc_partial  ,
     
    671842        if( arg[1] & 1 )
    672843        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
    673                 y_0 = taylor[ arg[2] * nc_taylor + 0 ];
     844                y_0 = taylor[ arg[2] * cap_order + 0 ];
    674845        }
    675846        else
     
    679850        if( arg[1] & 2 )
    680851        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
    681                 y_1 = taylor[ arg[3] * nc_taylor + 0 ];
     852                y_1 = taylor[ arg[3] * cap_order + 0 ];
    682853        }
    683854        else
  • trunk/cppad/local/cos_op.hpp

    r3232 r3301  
    2020Forward and reverse mode calculations for z = cos(x).
    2121*/
    22 
    2322
    2423/*!
     
    4443        size_t i_z         ,
    4544        size_t i_x         ,
    46         size_t nc_taylor   ,
     45        size_t cap_order   ,
    4746        Base*  taylor      )
    4847{       
     
    5150        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    5251        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    53         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     52        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5453        CPPAD_ASSERT_UNKNOWN( p <= q );
    5554
    5655        // Taylor coefficients corresponding to argument and result
    57         Base* x = taylor + i_x * nc_taylor;
    58         Base* c = taylor + i_z * nc_taylor;
    59         Base* s = c      -       nc_taylor;
     56        Base* x = taylor + i_x * cap_order;
     57        Base* c = taylor + i_z * cap_order;
     58        Base* s = c      -       cap_order;
    6059
    6160
    6261        // rest of this routine is identical for the following cases:
    6362        // forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op.
     63        // (except that there is a sign difference for the hyperbolic case).
    6464        size_t k;
    6565        if( p == 0 )
     
    8080        }
    8181}
     82/*!
     83Compute forward mode Taylor coefficient for result of op = CosOp.
     84
     85The C++ source code corresponding to this operation is
     86\verbatim
     87        z = cos(x)
     88\endverbatim
     89The auxillary result is
     90\verbatim
     91        y = sin(x)
     92\endverbatim
     93The value of y, and its derivatives, are computed along with the value
     94and derivatives of z.
     95
     96\copydetails forward_unary2_op_dir
     97*/
     98template <class Base>
     99inline void forward_cos_op_dir(
     100        size_t q           ,
     101        size_t r           ,
     102        size_t i_z         ,
     103        size_t i_x         ,
     104        size_t cap_order   ,
     105        Base*  taylor      )
     106{       
     107        // check assumptions
     108        CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
     109        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
     110        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
     111        CPPAD_ASSERT_UNKNOWN( 0 < q );
     112        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     113
     114        // Taylor coefficients corresponding to argument and result
     115        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     116        Base* x = taylor + i_x * num_taylor_per_var;
     117        Base* c = taylor + i_z * num_taylor_per_var;
     118        Base* s = c      -       num_taylor_per_var;
     119
     120
     121        // rest of this routine is identical for the following cases:
     122        // forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op
     123        // (except that there is a sign difference for the hyperbolic case).
     124        size_t m = (q-1) * r + 1;
     125        for(size_t ell = 0; ell < r; ell++)
     126        {       s[m+ell] =   Base(q) * x[m + ell] * c[0];
     127                c[m+ell] = - Base(q) * x[m + ell] * s[0];
     128                for(size_t k = 1; k < q; k++)
     129                {       s[m+ell] += Base(k) * x[(k-1)*r+1+ell] * c[(q-k-1)*r+1+ell];
     130                        c[m+ell] -= Base(k) * x[(k-1)*r+1+ell] * s[(q-k-1)*r+1+ell];
     131                }
     132                s[m+ell] /= Base(q);
     133                c[m+ell] /= Base(q);
     134        }
     135}
    82136
    83137/*!
     
    100154        size_t i_z         ,
    101155        size_t i_x         ,
    102         size_t nc_taylor   ,
     156        size_t cap_order   ,
    103157        Base*  taylor      )
    104158{
     
    107161        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    108162        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    109         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     163        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    110164
    111165        // Taylor coefficients corresponding to argument and result
    112         Base* x = taylor + i_x * nc_taylor;
    113         Base* c = taylor + i_z * nc_taylor;  // called z in documentation
    114         Base* s = c      -       nc_taylor;  // called y in documentation
     166        Base* x = taylor + i_x * cap_order;
     167        Base* c = taylor + i_z * cap_order;  // called z in documentation
     168        Base* s = c      -       cap_order;  // called y in documentation
    115169
    116170        c[0] = cos( x[0] );
     
    138192        size_t      i_z          ,
    139193        size_t      i_x          ,
    140         size_t      nc_taylor    ,
     194        size_t      cap_order    ,
    141195        const Base* taylor       ,
    142196        size_t      nc_partial   ,
     
    147201        CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
    148202        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    149         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     203        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    150204        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    151205
    152206        // Taylor coefficients and partials corresponding to argument
    153         const Base* x  = taylor  + i_x * nc_taylor;
     207        const Base* x  = taylor  + i_x * cap_order;
    154208        Base* px       = partial + i_x * nc_partial;
    155209
    156210        // Taylor coefficients and partials corresponding to first result
    157         const Base* c  = taylor  + i_z * nc_taylor; // called z in doc
     211        const Base* c  = taylor  + i_z * cap_order; // called z in doc
    158212        Base* pc       = partial + i_z * nc_partial;
    159213
    160214        // Taylor coefficients and partials corresponding to auxillary result
    161         const Base* s  = c  - nc_taylor; // called y in documentation
     215        const Base* s  = c  - cap_order; // called y in documentation
    162216        Base* ps       = pc - nc_partial;
    163217
  • trunk/cppad/local/cosh_op.hpp

    r3232 r3301  
    4444        size_t i_z         ,
    4545        size_t i_x         ,
    46         size_t nc_taylor   ,
     46        size_t cap_order   ,
    4747        Base*  taylor      )
    4848{       
     
    5151        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    5252        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    53         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     53        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5454        CPPAD_ASSERT_UNKNOWN( p <= q );
    5555
    5656        // Taylor coefficients corresponding to argument and result
    57         Base* x = taylor + i_x * nc_taylor;
    58         Base* c = taylor + i_z * nc_taylor;
    59         Base* s = c      -       nc_taylor;
     57        Base* x = taylor + i_x * cap_order;
     58        Base* c = taylor + i_z * cap_order;
     59        Base* s = c      -       cap_order;
    6060
    6161        // rest of this routine is identical for the following cases:
    6262        // forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op.
     63        // (except that there is a sign difference for hyperbolic case).
    6364        size_t k;
    6465        if( p == 0 )
     
    7980        }
    8081}
     82/*!
     83Compute forward mode Taylor coefficient for result of op = CoshOp.
     84
     85The C++ source code corresponding to this operation is
     86\verbatim
     87        z = cosh(x)
     88\endverbatim
     89The auxillary result is
     90\verbatim
     91        y = sinh(x)
     92\endverbatim
     93The value of y, and its derivatives, are computed along with the value
     94and derivatives of z.
     95
     96\copydetails forward_unary2_op_dir
     97*/
     98template <class Base>
     99inline void forward_cosh_op_dir(
     100        size_t q           ,
     101        size_t r           ,
     102        size_t i_z         ,
     103        size_t i_x         ,
     104        size_t cap_order   ,
     105        Base*  taylor      )
     106{       
     107        // check assumptions
     108        CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
     109        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
     110        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
     111        CPPAD_ASSERT_UNKNOWN( 0 < q );
     112        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     113
     114        // Taylor coefficients corresponding to argument and result
     115        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     116        Base* x = taylor + i_x * num_taylor_per_var;
     117        Base* s = taylor + i_z * num_taylor_per_var;
     118        Base* c = s      -       num_taylor_per_var;
     119
     120
     121        // rest of this routine is identical for the following cases:
     122        // forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op
     123        // (except that there is a sign difference for the hyperbolic case).
     124        size_t m = (q-1) * r + 1;
     125        for(size_t ell = 0; ell < r; ell++)
     126        {       s[m+ell] = Base(q) * x[m + ell] * c[0];
     127                c[m+ell] = Base(q) * x[m + ell] * s[0];
     128                for(size_t k = 1; k < q; k++)
     129                {       s[m+ell] += Base(k) * x[(k-1)*r+1+ell] * c[(q-k-1)*r+1+ell];
     130                        c[m+ell] += Base(k) * x[(k-1)*r+1+ell] * s[(q-k-1)*r+1+ell];
     131                }
     132                s[m+ell] /= Base(q);
     133                c[m+ell] /= Base(q);
     134        }
     135}
    81136
    82137/*!
     
    99154        size_t i_z         ,
    100155        size_t i_x         ,
    101         size_t nc_taylor   ,
     156        size_t cap_order   ,
    102157        Base*  taylor      )
    103158{
     
    106161        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    107162        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    108         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     163        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    109164
    110165        // Taylor coefficients corresponding to argument and result
    111         Base* x = taylor + i_x * nc_taylor;
    112         Base* c = taylor + i_z * nc_taylor;  // called z in documentation
    113         Base* s = c      -       nc_taylor;  // called y in documentation
     166        Base* x = taylor + i_x * cap_order;
     167        Base* c = taylor + i_z * cap_order;  // called z in documentation
     168        Base* s = c      -       cap_order;  // called y in documentation
    114169
    115170        c[0] = cosh( x[0] );
     
    137192        size_t      i_z          ,
    138193        size_t      i_x          ,
    139         size_t      nc_taylor    ,
     194        size_t      cap_order    ,
    140195        const Base* taylor       ,
    141196        size_t      nc_partial   ,
     
    146201        CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
    147202        CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
    148         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     203        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    149204        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    150205
    151206        // Taylor coefficients and partials corresponding to argument
    152         const Base* x  = taylor  + i_x * nc_taylor;
     207        const Base* x  = taylor  + i_x * cap_order;
    153208        Base* px       = partial + i_x * nc_partial;
    154209
    155210        // Taylor coefficients and partials corresponding to first result
    156         const Base* c  = taylor  + i_z * nc_taylor; // called z in doc
     211        const Base* c  = taylor  + i_z * cap_order; // called z in doc
    157212        Base* pc       = partial + i_z * nc_partial;
    158213
    159214        // Taylor coefficients and partials corresponding to auxillary result
    160         const Base* s  = c  - nc_taylor; // called y in documentation
     215        const Base* s  = c  - cap_order; // called y in documentation
    161216        Base* ps       = pc - nc_partial;
    162217
  • trunk/cppad/local/cskip_op.hpp

    r3232 r3301  
    9090<code>parameter [ arg[3] ]</code> is its value.
    9191
    92 \param nc_taylor [in]
     92\param cap_order [in]
    9393number of columns in the matrix containing the Taylor coefficients.
    9494
    9595\param taylor [in]
    9696If left is a variable,
    97 <code>taylor [ arg[2] * nc_taylor + 0 ]</code>
     97<code>taylor [ arg[2] * cap_order + 0 ]</code>
    9898is the zeroth order Taylor coefficient corresponding to left.
    9999If right is a variable,
    100 <code>taylor [ arg[3] * nc_taylor + 0 ]</code>
     100<code>taylor [ arg[3] * cap_order + 0 ]</code>
    101101is the zeroth order Taylor coefficient corresponding to right.
    102102
     
    112112        size_t               num_par        ,
    113113        const Base*          parameter      ,
    114         size_t               nc_taylor      ,
     114        size_t               cap_order      ,
    115115        Base*                taylor         ,
    116116        bool*                cskip_op       )
     
    122122        if( arg[1] & 1 )
    123123        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
    124                 left = taylor[ arg[2] * nc_taylor + 0 ];
     124                left = taylor[ arg[2] * cap_order + 0 ];
    125125                CPPAD_ASSERT_UNKNOWN( IdenticalPar(left) );
    126126        }
     
    132132        if( arg[1] & 2 )
    133133        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= i_z );
    134                 right = taylor[ arg[3] * nc_taylor + 0 ];
     134                right = taylor[ arg[3] * cap_order + 0 ];
    135135                CPPAD_ASSERT_UNKNOWN( IdenticalPar(right) );
    136136        }
  • trunk/cppad/local/csum_op.hpp

    r3232 r3301  
    6767is the parameter vector for this operation sequence.
    6868
    69 \param nc_taylor
     69\param cap_order
    7070number of colums in the matrix containing all the Taylor coefficients.
    7171
    7272\param taylor
    73 \b Input: <tt>taylor [ arg[2+i] * nc_taylor + k ]</tt>
     73\b Input: <tt>taylor [ arg[2+i] * cap_order + k ]</tt>
    7474for <tt>i = 1 , ... , m</tt>
    7575and <tt>k = 0 , ... , q</tt>
    7676is the k-th order Taylor coefficient corresponding to <tt>x(i)</tt>
    7777\n
    78 \b Input: <tt>taylor [ arg[2+m+i] * nc_taylor + k ]</tt>
     78\b Input: <tt>taylor [ arg[2+m+i] * cap_order + k ]</tt>
    7979for <tt>i = 1 , ... , n</tt>
    8080and <tt>k = 0 , ... , q</tt>
    8181is the k-th order Taylor coefficient corresponding to <tt>y(i)</tt>
    8282\n
    83 \b Input: <tt>taylor [ i_z * nc_taylor + k ]</tt>
     83\b Input: <tt>taylor [ i_z * cap_order + k ]</tt>
    8484for k = 0 , ... , p,
    8585is the k-th order Taylor coefficient corresponding to z.
    8686\n
    87 \b Output: <tt>taylor [ i_z * nc_taylor + k ]</tt>
     87\b Output: <tt>taylor [ i_z * cap_order + k ]</tt>
    8888for k = p , ... , q,
    8989is the \a k-th order Taylor coefficient corresponding to z.
     
    9797        size_t        num_par     ,
    9898        const Base*   parameter   ,
    99         size_t        nc_taylor   ,
     99        size_t        cap_order   ,
    100100        Base*         taylor      )
    101101{       Base zero(0);
     
    104104        // check assumptions
    105105        CPPAD_ASSERT_UNKNOWN( NumRes(CSumOp) == 1 );
    106         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     106        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    107107        CPPAD_ASSERT_UNKNOWN( p <= q );
    108108        CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
     
    112112
    113113        // Taylor coefficients corresponding to result
    114         Base* z = taylor + i_z    * nc_taylor;
     114        Base* z = taylor + i_z    * cap_order;
    115115        for(k = p; k <= q; k++)
    116116                z[k] = zero;
     
    122122        while(i--)
    123123        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
    124                 x     = taylor + arg[++j] * nc_taylor;
     124                x     = taylor + arg[++j] * cap_order;
    125125                for(k = p; k <= q; k++)
    126126                        z[k] += x[k];
     
    129129        while(i--)
    130130        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
    131                 x     = taylor + arg[++j] * nc_taylor;
     131                x     = taylor + arg[++j] * cap_order;
    132132                for(k = p; k <= q; k++)
    133133                        z[k] -= x[k];
     134        }       
     135}
     136
     137/*!
     138Multiple direction forward mode Taylor coefficients for op = CsumOp.
     139
     140This operation is
     141\verbatim
     142        z = s + x(1) + ... + x(m) - y(1) - ... - y(n).
     143\endverbatim
     144
     145\tparam Base
     146base type for the operator; i.e., this operation was recorded
     147using AD<Base> and computations by this routine are done using type
     148\a Base.
     149
     150\param q
     151order ot the Taylor coefficients that we are computing.
     152
     153\param r
     154number of directions for Taylor coefficients that we are computing.
     155
     156\param i_z
     157variable index corresponding to the result for this operation;
     158i.e. the row index in \a taylor corresponding to z.
     159
     160\param arg
     161\a arg[0]
     162is the number of addition variables in this cummulative summation; i.e.,
     163<tt>m</tt>.
     164\n
     165\a arg[1]
     166is the number of subtraction variables in this cummulative summation; i.e.,
     167\c m.
     168\n
     169<tt>parameter[ arg[2] ]</tt>
     170is the parameter value \c s in this cummunative summation.
     171\n
     172<tt>arg[2+i]</tt>
     173for <tt>i = 1 , ... , m</tt> is the variable index of <tt>x(i)</tt>.
     174\n
     175<tt>arg[2+arg[0]+i]</tt>
     176for <tt>i = 1 , ... , n</tt> is the variable index of <tt>y(i)</tt>.
     177
     178\param num_par
     179is the number of parameters in \a parameter.
     180
     181\param parameter
     182is the parameter vector for this operation sequence.
     183
     184\param cap_order
     185number of colums in the matrix containing all the Taylor coefficients.
     186
     187\param taylor
     188\b Input: <tt>taylor [ arg[2+i]*((cap_order-1)*r + 1) + 0 ]</tt>
     189for <tt>i = 1 , ... , m</tt>
     190is the 0-th order Taylor coefficient corresponding to <tt>x(i)</tt> and
     191<tt>taylor [ arg[2+i]*((cap_order-1)*r + 1) + (q-1)*r + ell + 1 ]</tt>
     192for <tt>i = 1 , ... , m</tt>,
     193<tt>ell = 0 , ... , r-1</tt>
     194is the q-th order Taylor coefficient corresponding to <tt>x(i)</tt>
     195and direction ell.
     196\n
     197\b Input: <tt>taylor [ arg[2+m+i]*((cap_order-1)*r + 1) + 0 ]</tt>
     198for <tt>i = 1 , ... , n</tt>
     199is the 0-th order Taylor coefficient corresponding to <tt>y(i)</tt> and
     200<tt>taylor [ arg[2+m+i]*((cap_order-1)*r + 1) + (q-1)*r + ell + 1 ]</tt>
     201for <tt>i = 1 , ... , n</tt>,
     202<tt>ell = 0 , ... , r-1</tt>
     203is the q-th order Taylor coefficient corresponding to <tt>y(i)</tt>
     204and direction ell.
     205\n
     206\b Output: <tt>taylor [ i_z*((cap_order-1)*r+1) + (q-1)*r + ell + 1 ]</tt>
     207is the \a q-th order Taylor coefficient corresponding to z
     208for direction <tt>ell = 0 , ... , r-1</tt>.
     209*/
     210template <class Base>
     211inline void forward_csum_op_dir(
     212        size_t        q           ,
     213        size_t        r           ,
     214        size_t        i_z         ,
     215        const addr_t* arg         ,
     216        size_t        num_par     ,
     217        const Base*   parameter   ,
     218        size_t        cap_order   ,
     219        Base*         taylor      )
     220{       Base zero(0);
     221        size_t i, j, ell;
     222
     223        // check assumptions
     224        CPPAD_ASSERT_UNKNOWN( NumRes(CSumOp) == 1 );
     225        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     226        CPPAD_ASSERT_UNKNOWN( 0 < q );
     227        CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
     228        CPPAD_ASSERT_UNKNOWN(
     229                arg[0] + arg[1] == arg[ arg[0] + arg[1] + 3 ]
     230        );
     231
     232        // Taylor coefficients corresponding to result
     233        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     234        size_t m                  = (q-1)*r + 1;
     235        Base* z = taylor + i_z * num_taylor_per_var + m;
     236        for(ell = 0; ell < r; ell++)
     237                z[ell] = zero;
     238        Base* x;
     239        i = arg[0];
     240        j = 2;
     241        while(i--)
     242        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
     243                x = taylor + arg[++j] * num_taylor_per_var + m;
     244                for(ell = 0; ell < r; ell++)
     245                        z[ell] += x[ell];
     246        }       
     247        i = arg[1];
     248        while(i--)
     249        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
     250                x = taylor + arg[++j] * num_taylor_per_var + m;
     251                for(ell = 0; ell < r; ell++)
     252                        z[ell] -= x[ell];
    134253        }       
    135254}
  • trunk/cppad/local/dependent.hpp

    r3214 r3301  
    142142// BEGIN CppAD namespace
    143143namespace CppAD {
     144
     145/*!
     146\file dependent.hpp
     147Different versions of Dependent function.
     148*/
    144149
    145150/*!
     
    276281        compare_change_       = 0;
    277282        num_order_taylor_     = 0;
     283        num_direction_taylor_ = 0;
    278284        cap_order_taylor_     = 0;
    279285
  • trunk/cppad/local/discrete_op.hpp

    r3232 r3301  
    1818/*!
    1919\file discrete_op.hpp
    20 Zero order forward mode for z = f(x) where f is piecewise constant.
     20Forward mode for z = f(x) where f is piecewise constant.
    2121*/
    2222
    2323
    2424/*!
    25 Compute zero order forward mode Taylor coefficient for result of op = DisOp.
     25forward mode Taylor coefficient for result of op = DisOp.
    2626
    2727The C++ source code corresponding to this operation is
     
    3636using AD< \a Base > and computations by this routine are done using type
    3737\a Base .
     38
     39\param p
     40is the lowest order Taylor coefficient that will be calculated.
     41
     42\param q
     43is the highest order Taylor coefficient that will be calculated.
     44
     45\param r
     46is the number of directions, for each order,
     47that will be calculated (except for order zero wich only has one direction).
    3848
    3949\param i_z
     
    5262i.e. the row index in \a taylor corresponding to x.
    5363
    54 \param nc_taylor
    55 number of colums in the matrix containing all the Taylor coefficients.
     64\param cap_order
     65maximum number of orders that will fit in the taylor array.
     66
     67\par tpv
     68We use the notation
     69<code>tpv = (cap_order-1) * r + 1</code>
     70which is the number of Taylor coefficients per variable
    5671
    5772\param taylor
    58 \b Input: \a taylor [ \a arg[1] * \a nc_taylor + 0 ]
    59 is the zero order Taylor coefficient corresponding to x. 
     73\b Input: <code>taylor [ arg[1] * tpv + 0 ]</code>
     74is the zero order Taylor coefficient corresponding to x.
    6075\n
    61 \b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
     76\b Output: if <code>p == 0</code>
     77<code>taylor [ i_z * tpv + 0 ]</code>
    6278is the zero order Taylor coefficient corresponding to z.
     79For k = max(p, 1), ... , q,
     80<code>taylor [ i_z * tpv + (k-1)*r + 1 + ell ]</code>
     81is the k-th order Taylor coefficient corresponding to z
     82(which is zero).
    6383
    6484\par Checked Assertions where op is the unary operator with one result:
    6585\li NumArg(op) == 2
    6686\li NumRes(op) == 1
    67 \li \a arg[1] < \a i_z
    68 \li \a 0 < \a nc_taylor
     87\li arg[1] < i_z
     88\li q < cap_order
     89\li 0 < r
    6990*/
    7091template <class Base>
    71 inline void forward_dis_op_0(
     92inline void forward_dis_op(
     93        size_t        p           ,
     94        size_t        q           ,
     95        size_t        r           ,
    7296        size_t        i_z         ,
    7397        const addr_t* arg         ,
    74         size_t        nc_taylor   ,
     98        size_t        cap_order   ,
    7599        Base*         taylor      )
    76100{       
     
    79103        CPPAD_ASSERT_UNKNOWN( NumRes(DisOp) == 1 );
    80104        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    81         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     105        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     106        CPPAD_ASSERT_UNKNOWN( 0 < r );
    82107
    83108        // Taylor coefficients corresponding to argument and result
    84         Base* x = taylor + arg[1] * nc_taylor;
    85         Base* z = taylor + i_z * nc_taylor;
     109        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     110        Base* x = taylor + arg[1] * num_taylor_per_var;
     111        Base* z = taylor +    i_z * num_taylor_per_var;
    86112
    87         z[0]  = discrete<Base>::eval(arg[0], x[0]);
     113        if( p == 0 )
     114        {       z[0]  = discrete<Base>::eval(arg[0], x[0]);
     115                p++;
     116        }
     117        for(size_t ell = 0; ell < r; ell++)
     118                for(size_t k = p; k <= q; k++)
     119                        z[ (k-1) * r + 1 + ell ] = Base(0);
    88120}
    89121
  • trunk/cppad/local/div_op.hpp

    r3232 r3301  
    4242        const addr_t* arg         ,
    4343        const Base*   parameter   ,
    44         size_t        nc_taylor   ,
     44        size_t        cap_order   ,
    4545        Base*         taylor      )
    4646{
     
    5050        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    5151        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    52         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     52        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5353        CPPAD_ASSERT_UNKNOWN( p <= q );
    5454
    5555        // Taylor coefficients corresponding to arguments and result
    56         Base* x = taylor + arg[0] * nc_taylor;
    57         Base* y = taylor + arg[1] * nc_taylor;
    58         Base* z = taylor + i_z    * nc_taylor;
     56        Base* x = taylor + arg[0] * cap_order;
     57        Base* y = taylor + arg[1] * cap_order;
     58        Base* z = taylor + i_z    * cap_order;
    5959
    6060
     
    6969        }
    7070}
    71 
    72 
    73 /*!
    74 Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
     71/*!
     72Multiple directions forward mode Taylor coefficients for op = DivvvOp.
    7573
    7674The C++ source code corresponding to this operation is
     
    8280and the argument \a parameter is not used.
    8381
    84 \copydetails forward_binary_op_0
    85 */
    86 
    87 template <class Base>
    88 inline void forward_divvv_op_0(
    89         size_t        i_z         ,
    90         const addr_t* arg         ,
    91         const Base*   parameter   ,
    92         size_t        nc_taylor   ,
     82\copydetails forward_binary_op_dir
     83*/
     84
     85template <class Base>
     86inline void forward_divvv_op_dir(
     87        size_t        q           ,
     88        size_t        r           ,
     89        size_t        i_z         ,
     90        const addr_t* arg         ,
     91        const Base*   parameter   ,
     92        size_t        cap_order   ,
    9393        Base*         taylor      )
    9494{
     
    9898        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    9999        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    100 
    101         // Taylor coefficients corresponding to arguments and result
    102         Base* x = taylor + arg[0] * nc_taylor;
    103         Base* y = taylor + arg[1] * nc_taylor;
    104         Base* z = taylor + i_z    * nc_taylor;
    105 
    106         z[0] = x[0] / y[0];
    107 }
    108 
    109 /*!
    110 Compute reverse mode partial derivatives for result of op = DivvvOp.
     100        CPPAD_ASSERT_UNKNOWN( 0 < q );
     101        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     102
     103        // Taylor coefficients corresponding to arguments and result
     104        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     105        Base* x = taylor + arg[0] * num_taylor_per_var;
     106        Base* y = taylor + arg[1] * num_taylor_per_var;
     107        Base* z = taylor + i_z    * num_taylor_per_var;
     108
     109
     110        // Using CondExp, it can make sense to divide by zero,
     111        // so do not make it an error.
     112        size_t m = (q-1) * r + 1;
     113        for(size_t ell = 0; ell < r; ell++)
     114        {       z[m+ell] = x[m+ell] - z[0] * y[m+ell];
     115                for(size_t k = 1; k < q; k++)           
     116                        z[m+ell] -= z[(q-k-1)*r+1+ell] * y[(k-1)*r+1+ell];
     117                z[m+ell] /= y[0];
     118        }
     119}
     120
     121
     122/*!
     123Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
    111124
    112125The C++ source code corresponding to this operation is
     
    118131and the argument \a parameter is not used.
    119132
     133\copydetails forward_binary_op_0
     134*/
     135
     136template <class Base>
     137inline void forward_divvv_op_0(
     138        size_t        i_z         ,
     139        const addr_t* arg         ,
     140        const Base*   parameter   ,
     141        size_t        cap_order   ,
     142        Base*         taylor      )
     143{
     144        // check assumptions
     145        CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
     146        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
     147        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
     148        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     149
     150        // Taylor coefficients corresponding to arguments and result
     151        Base* x = taylor + arg[0] * cap_order;
     152        Base* y = taylor + arg[1] * cap_order;
     153        Base* z = taylor + i_z    * cap_order;
     154
     155        z[0] = x[0] / y[0];
     156}
     157
     158/*!
     159Compute reverse mode partial derivatives for result of op = DivvvOp.
     160
     161The C++ source code corresponding to this operation is
     162\verbatim
     163        z = x / y
     164\endverbatim
     165In the documentation below,
     166this operations is for the case where both x and y are variables
     167and the argument \a parameter is not used.
     168
    120169\copydetails reverse_binary_op
    121170*/
     
    127176        const addr_t* arg         ,
    128177        const Base*   parameter   ,
    129         size_t        nc_taylor   ,
     178        size_t        cap_order   ,
    130179        const Base*   taylor      ,
    131180        size_t        nc_partial  ,
     
    137186        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    138187        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    139         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     188        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    140189        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    141190
    142191        // Arguments
    143         const Base* y  = taylor + arg[1] * nc_taylor;
    144         const Base* z  = taylor + i_z    * nc_taylor;
     192        const Base* y  = taylor + arg[1] * cap_order;
     193        const Base* z  = taylor + i_z    * cap_order;
    145194
    146195        // Partial derivatives corresponding to arguments and result
     
    190239        const addr_t* arg         ,
    191240        const Base*   parameter   ,
    192         size_t        nc_taylor   ,
     241        size_t        cap_order   ,
    193242        Base*         taylor      )
    194243{
     
    197246        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
    198247        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    199         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     248        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    200249        CPPAD_ASSERT_UNKNOWN( p <= q );
    201250
    202251        // Taylor coefficients corresponding to arguments and result
    203         Base* y = taylor + arg[1] * nc_taylor;
    204         Base* z = taylor + i_z    * nc_taylor;
     252        Base* y = taylor + arg[1] * cap_order;
     253        Base* z = taylor + i_z    * cap_order;
    205254
    206255        // Paraemter value
     
    221270        }
    222271}
    223 
    224 /*!
    225 Compute zero order forward mode Taylor coefficient for result of op = DivpvOp.
     272/*!
     273Multiple directions forward mode Taylor coefficients for op = DivpvOp.
    226274
    227275The C++ source code corresponding to this operation is
     
    232280this operations is for the case where x is a parameter and y is a variable.
    233281
    234 \copydetails forward_binary_op_0
    235 */
    236 
    237 template <class Base>
    238 inline void forward_divpv_op_0(
    239         size_t        i_z         ,
    240         const addr_t* arg         ,
    241         const Base*   parameter   ,
    242         size_t        nc_taylor   ,
     282\copydetails forward_binary_op_dir
     283*/
     284
     285template <class Base>
     286inline void forward_divpv_op_dir(
     287        size_t        q           ,
     288        size_t        r           ,
     289        size_t        i_z         ,
     290        const addr_t* arg         ,
     291        const Base*   parameter   ,
     292        size_t        cap_order   ,
    243293        Base*         taylor      )
    244294{
     
    247297        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
    248298        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     299        CPPAD_ASSERT_UNKNOWN( 0 < q );
     300        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     301
     302        // Taylor coefficients corresponding to arguments and result
     303        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     304        Base* y = taylor + arg[1] * num_taylor_per_var;
     305        Base* z = taylor + i_z    * num_taylor_per_var;
     306
     307        // Using CondExp, it can make sense to divide by zero,
     308        // so do not make it an error.
     309        size_t m = (q-1) * r + 1;
     310        for(size_t ell = 0; ell < r; ell++)
     311        {       z[m+ell] = - z[0] * y[m+ell];
     312                for(size_t k = 1; k < q; k++)
     313                        z[m+ell] -= z[(q-k-1)*r+1+ell] * y[(k-1)*r+1+ell];
     314                z[m+ell] /= y[0];
     315        }
     316}
     317
     318/*!
     319Compute zero order forward mode Taylor coefficient for result of op = DivpvOp.
     320
     321The C++ source code corresponding to this operation is
     322\verbatim
     323        z = x / y
     324\endverbatim
     325In the documentation below,
     326this operations is for the case where x is a parameter and y is a variable.
     327
     328\copydetails forward_binary_op_0
     329*/
     330
     331template <class Base>
     332inline void forward_divpv_op_0(
     333        size_t        i_z         ,
     334        const addr_t* arg         ,
     335        const Base*   parameter   ,
     336        size_t        cap_order   ,
     337        Base*         taylor      )
     338{
     339        // check assumptions
     340        CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
     341        CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
     342        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    249343
    250344        // Paraemter value
     
    252346
    253347        // Taylor coefficients corresponding to arguments and result
    254         Base* y = taylor + arg[1] * nc_taylor;
    255         Base* z = taylor + i_z    * nc_taylor;
     348        Base* y = taylor + arg[1] * cap_order;
     349        Base* z = taylor + i_z    * cap_order;
    256350
    257351        z[0] = x / y[0];
     
    277371        const addr_t* arg         ,
    278372        const Base*   parameter   ,
    279         size_t        nc_taylor   ,
     373        size_t        cap_order   ,
    280374        const Base*   taylor      ,
    281375        size_t        nc_partial  ,
     
    286380        CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
    287381        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    288         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     382        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    289383        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    290384
    291385        // Arguments
    292         const Base* y = taylor + arg[1] * nc_taylor;
    293         const Base* z = taylor + i_z    * nc_taylor;
     386        const Base* y = taylor + arg[1] * cap_order;
     387        const Base* z = taylor + i_z    * cap_order;
    294388
    295389        // Partial derivatives corresponding to arguments and result
     
    338432        const addr_t* arg         ,
    339433        const Base*   parameter   ,
    340         size_t        nc_taylor   ,
     434        size_t        cap_order   ,
    341435        Base*         taylor      )
    342436{
     
    345439        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
    346440        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    347         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     441        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    348442        CPPAD_ASSERT_UNKNOWN( p <= q );
    349443
    350444        // Taylor coefficients corresponding to arguments and result
    351         Base* x = taylor + arg[0] * nc_taylor;
    352         Base* z = taylor + i_z    * nc_taylor;
     445        Base* x = taylor + arg[0] * cap_order;
     446        Base* z = taylor + i_z    * cap_order;
    353447
    354448        // Parameter value
     
    360454                z[d] = x[d] / y;
    361455}
    362 
    363 
    364 /*!
    365 Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
     456/*!
     457Multiple direction forward mode Taylor coefficients for op = DivvvOp.
    366458
    367459The C++ source code corresponding to this operation is
     
    372464this operations is for the case where x is a variable and y is a parameter.
    373465
    374 \copydetails forward_binary_op_0
    375 */
    376 
    377 template <class Base>
    378 inline void forward_divvp_op_0(
    379         size_t        i_z         ,
    380         const addr_t* arg         ,
    381         const Base*   parameter   ,
    382         size_t        nc_taylor   ,
     466\copydetails forward_binary_op_dir
     467*/
     468
     469template <class Base>
     470inline void forward_divvp_op_dir(
     471        size_t        q           ,
     472        size_t        r           ,
     473        size_t        i_z         ,
     474        const addr_t* arg         ,
     475        const Base*   parameter   ,
     476        size_t        cap_order   ,
    383477        Base*         taylor      )
    384478{
     
    387481        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
    388482        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
     483        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     484        CPPAD_ASSERT_UNKNOWN( 0 < q  );
     485
     486        // Taylor coefficients corresponding to arguments and result
     487        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     488        Base* x = taylor + arg[0] * num_taylor_per_var;
     489        Base* z = taylor +    i_z * num_taylor_per_var;
    389490
    390491        // Parameter value
    391492        Base y = parameter[ arg[1] ];
    392493
    393         // Taylor coefficients corresponding to arguments and result
    394         Base* x = taylor + arg[0] * nc_taylor;
    395         Base* z = taylor + i_z    * nc_taylor;
     494        // Using CondExp and multiple levels of AD, it can make sense
     495        // to divide by zero so do not make it an error.
     496        size_t m = (q-1)*r + 1;
     497        for(size_t ell = 0; ell < r; ell++)
     498                z[m + ell] = x[m + ell] / y;
     499}
     500
     501
     502/*!
     503Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
     504
     505The C++ source code corresponding to this operation is
     506\verbatim
     507        z = x / y
     508\endverbatim
     509In the documentation below,
     510this operations is for the case where x is a variable and y is a parameter.
     511
     512\copydetails forward_binary_op_0
     513*/
     514
     515template <class Base>
     516inline void forward_divvp_op_0(
     517        size_t        i_z         ,
     518        const addr_t* arg         ,
     519        const Base*   parameter   ,
     520        size_t        cap_order   ,
     521        Base*         taylor      )
     522{
     523        // check assumptions
     524        CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
     525        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
     526        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
     527
     528        // Parameter value
     529        Base y = parameter[ arg[1] ];
     530
     531        // Taylor coefficients corresponding to arguments and result
     532        Base* x = taylor + arg[0] * cap_order;
     533        Base* z = taylor + i_z    * cap_order;
    396534
    397535        z[0] = x[0] / y;
     
    417555        const addr_t* arg         ,
    418556        const Base*   parameter   ,
    419         size_t        nc_taylor   ,
     557        size_t        cap_order   ,
    420558        const Base*   taylor      ,
    421559        size_t        nc_partial  ,
     
    426564        CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
    427565        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    428         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     566        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    429567        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    430568
  • trunk/cppad/local/exp_op.hpp

    r3232 r3301  
    3838        size_t i_z         ,
    3939        size_t i_x         ,
    40         size_t nc_taylor   ,
     40        size_t cap_order   ,
    4141        Base*  taylor      )
    4242{       
     
    4545        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
    4646        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    47         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     47        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4848        CPPAD_ASSERT_UNKNOWN( p <= q );
    4949
    5050        // Taylor coefficients corresponding to argument and result
    51         Base* x = taylor + i_x * nc_taylor;
    52         Base* z = taylor + i_z * nc_taylor;
     51        Base* x = taylor + i_x * cap_order;
     52        Base* z = taylor + i_z * cap_order;
    5353
    5454        size_t k;
     
    6363                        z[j] += Base(k) * x[k] * z[j-k];
    6464                z[j] /= Base(j);
     65        }
     66}
     67
     68
     69/*!
     70Multiple direction forward mode Taylor coefficient for op = ExpOp.
     71
     72The C++ source code corresponding to this operation is
     73\verbatim
     74        z = exp(x)
     75\endverbatim
     76
     77\copydetails forward_unary1_op_dir
     78*/
     79template <class Base>
     80inline void forward_exp_op_dir(
     81        size_t q           ,
     82        size_t r           ,
     83        size_t i_z         ,
     84        size_t i_x         ,
     85        size_t cap_order   ,
     86        Base*  taylor      )
     87{       
     88        // check assumptions
     89        CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
     90        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
     91        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     92        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     93        CPPAD_ASSERT_UNKNOWN( 0 < q );
     94
     95        // Taylor coefficients corresponding to argument and result
     96        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     97        Base* x = taylor + i_x * num_taylor_per_var;
     98        Base* z = taylor + i_z * num_taylor_per_var;
     99
     100        size_t m = (q-1)*r + 1;
     101        for(size_t ell = 0; ell < r; ell++)
     102        {       z[m+ell] = Base(q) * x[m+ell] * z[0];
     103                for(size_t k = 1; k < q; k++)
     104                        z[m+ell] += Base(k) * x[(k-1)*r+ell+1] * z[(q-k-1)*r+ell+1];
     105                z[m+ell] /= Base(q);
    65106        }
    66107}
     
    80121        size_t i_z         ,
    81122        size_t i_x         ,
    82         size_t nc_taylor   ,
     123        size_t cap_order   ,
    83124        Base*  taylor      )
    84125{
     
    87128        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
    88129        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    89         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     130        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    90131
    91132        // Taylor coefficients corresponding to argument and result
    92         Base* x = taylor + i_x * nc_taylor;
    93         Base* z = taylor + i_z * nc_taylor;
     133        Base* x = taylor + i_x * cap_order;
     134        Base* z = taylor + i_z * cap_order;
    94135
    95136        z[0] = exp( x[0] );
     
    111152        size_t      i_z          ,
    112153        size_t      i_x          ,
    113         size_t      nc_taylor    ,
     154        size_t      cap_order    ,
    114155        const Base* taylor       ,
    115156        size_t      nc_partial   ,
     
    120161        CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
    121162        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    122         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     163        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    123164        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    124165
    125166        // Taylor coefficients and partials corresponding to argument
    126         const Base* x  = taylor  + i_x * nc_taylor;
     167        const Base* x  = taylor  + i_x * cap_order;
    127168        Base* px       = partial + i_x * nc_partial;
    128169
    129170        // Taylor coefficients and partials corresponding to result
    130         const Base* z  = taylor  + i_z * nc_taylor;
     171        const Base* z  = taylor  + i_z * cap_order;
    131172        Base* pz       = partial + i_z * nc_partial;
    132173
  • trunk/cppad/local/for_jac_sweep.hpp

    r3262 r3301  
    181181# if CPPAD_FOR_JAC_SWEEP_TRACE
    182182        std::cout << std::endl;
    183         CppAD::vector<bool> z_value(limit);
     183        CppAD::vectorBool z_value(limit);
    184184# endif
    185185
     
    715715                        i_var,
    716716                        op,
    717                         arg_tmp,
     717                        arg_tmp
     718                );
     719                if( NumRes(op) > 0 ) printOpResult(
     720                        std::cout,
    718721                        1,
    719722                        &z_value,
    720723                        0,
    721                         (CppAD::vector<bool> *) CPPAD_NULL
     724                        (CppAD::vectorBool *) CPPAD_NULL
    722725                );
     726                std::cout << std::endl;
    723727        }
    724728        std::cout << std::endl;
  • trunk/cppad/local/forward.hpp

    r3232 r3301  
    2121/*!
    2222\file forward.hpp
    23 User interface to forward mode computations
     23User interface to forward mode computations.
    2424*/
    2525
    2626/*!
    27 Arbitrary order, one direction, forward mode Taylor coefficieints.
     27Multiple orders, one direction, forward mode Taylor coefficieints.
    2828
    2929\tparam Base
     
    3131recording of operations used the type AD<Base>.
    3232
    33 \tparam Vector
     33\tparam VectorBase
    3434is a Simple Vector class with eleements of type Base.
    3535
     
    5252
    5353\return
    54 contains Taylor coefficients for the independent variables.
     54contains Taylor coefficients for the dependent variables.
    5555The size of the return value y is <code>m*(q+1-p)</code>.
    5656For <code>i = 0, ... , m-1</code>,
     
    7575
    7676template <typename Base>
    77 template <typename Vector>
    78 Vector ADFun<Base>::Forward(
    79         size_t q                    ,
    80         const Vector& xq            ,
    81         std::ostream& s             )
     77template <typename VectorBase>
     78VectorBase ADFun<Base>::Forward(
     79        size_t              q         ,
     80        const VectorBase&   xq        ,
     81              std::ostream& s         )
    8282{       // temporary indices
    8383        size_t i, j, k;
     
    9090
    9191        // check Vector is Simple Vector class with Base type elements
    92         CheckSimpleVector<Base, Vector>();
     92        CheckSimpleVector<Base, VectorBase>();
    9393
    9494
     
    106106                " ADFun\nis less than q and xq.size() != n*(q+1)."
    107107        ); 
    108         // does taylor_ need more orders or different number of directions
    109         if( cap_order_taylor_ <= q )
     108        CPPAD_ASSERT_KNOWN(
     109                p <= 1 || num_direction_taylor_ == 1,
     110                "Forward(q, xq): computing order q >= 2"
     111                " and number of directions is not one."
     112                "\nMust use Forward(q, r, xq) for this case"
     113        );
     114        // does taylor_ need more orders or fewer directions
     115        if( (cap_order_taylor_ <= q) | (num_direction_taylor_ != 1) )
    110116        {       if( p == 0 )
    111117                {       // no need to copy old values during capacity_order
    112118                        num_order_taylor_ = 0;
    113119                }
     120                else    num_order_taylor_ = q;
    114121                size_t c = std::max(q + 1, cap_order_taylor_);
    115                 capacity_order(c);
     122                size_t r = 1;
     123                capacity_order(c, r);
    116124        }
    117125        CPPAD_ASSERT_UNKNOWN( cap_order_taylor_ > q );
     126        CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == 1 );
    118127
    119128        // short hand notation for order capacity
     
    159168
    160169        // return Taylor coefficients for dependent variables
    161         Vector yq;
     170        VectorBase yq;
    162171        if( p == q )
    163172        {       yq.resize(m);
     
    209218}
    210219
     220/*!
     221One order, multiple directions, forward mode Taylor coefficieints.
     222
     223\tparam Base
     224The type used during the forward mode computations; i.e., the corresponding
     225recording of operations used the type AD<Base>.
     226
     227\tparam VectorBase
     228is a Simple Vector class with eleements of type Base.
     229
     230\param q
     231is the order for this forward mode computation,
     232<code>q > 0</code>.
     233There must be at least <code>q</code> Taylor coefficients
     234per variable before this call.
     235After this call there will be <code>q+1</code>
     236Taylor coefficients per variable.
     237
     238\param r
     239is the number of directions for this calculation.
     240If <code>q != 1</code>, \c r must be the same as in the previous
     241call to Forward where \c q was equal to one.
     242
     243\param xq
     244contains Taylor coefficients for the independent variables.
     245The size of xq must either be <code>r*n</code>,
     246For <code>j = 0 , ... , n-1</code>,
     247<code>ell = 0, ... , r-1</code>,
     248<code>xq[ ( r*j + ell ]</code>
     249is the q-th order coefficient for the j-th independent variable
     250and the ell-th direction.
     251
     252\return
     253contains Taylor coefficients for the dependent variables.
     254The size of the return value \c y is <code>r*m</code>.
     255For <code>i = 0, ... , m-1</code>,
     256<code>ell = 0, ... , r-1</code>,
     257<code>y[ r*i + ell ]</code>
     258is the q-th order coefficient for the i-th dependent variable
     259and the ell-th direction.
     260
     261\par taylor_
     262The Taylor coefficients up to order <code>q-1</code> are inputs
     263and the coefficents of order \c q are outputs.
     264Let <code>N = num_var_tape_</code>, and
     265<code>C = cap_order_taylor_</code>.
     266Note that for
     267<code>i = 1 , ..., N-1</code>,
     268<code>taylor_[ (C-1)*r*i + i + 0 ]</code>
     269is the zero order cofficent,
     270for the i-th varaible, and all directions.
     271For <code>i = 1 , ..., N-1</code>,
     272<code>k = 1 , ..., q</code>,
     273<code>ell = 0 , ..., r-1</code>,
     274<code>taylor_[ (C-1)*r*i + i + (k-1)*r + ell + 1 ]</code>
     275is the k-th order cofficent,
     276for the i-th varaible, and ell-th direction.
     277(The first independent variable has index one on the tape
     278and there is no variable with index zero.)
     279*/
     280
     281template <typename Base>
     282template <typename VectorBase>
     283VectorBase ADFun<Base>::Forward(
     284        size_t              q         ,
     285        size_t              r         ,
     286        const VectorBase&   xq        )
     287{       // temporary indices
     288        size_t i, j, ell;
     289
     290        // number of independent variables
     291        size_t n = ind_taddr_.size();
     292
     293        // number of dependent variables
     294        size_t m = dep_taddr_.size();
     295
     296        // check Vector is Simple Vector class with Base type elements
     297        CheckSimpleVector<Base, VectorBase>();
     298
     299        CPPAD_ASSERT_KNOWN( q > 0, "Forward(q, r, xq): q == 0" );
     300        CPPAD_ASSERT_KNOWN(
     301                size_t(xq.size()) == r * n,
     302                "Forward(q, r, xq): xq.size() is not equal r * n"
     303        );
     304        CPPAD_ASSERT_KNOWN(
     305                q <= num_order_taylor_ ,
     306                "Forward(q, r, xq): Number of Taylor coefficient orders stored in"
     307                " this ADFun is less than q"
     308        ); 
     309        CPPAD_ASSERT_KNOWN(
     310                q == 1 || num_direction_taylor_ == r ,
     311                "Forward(q, r, xq): q > 1 and number of Taylor directions r"
     312                " is not same as previous Forward(1, r, xq)"
     313        );
     314               
     315        // does taylor_ need more orders or new number of directions
     316        if( cap_order_taylor_ <= q || num_direction_taylor_ != r )
     317        {       if( num_direction_taylor_ != r )
     318                        num_order_taylor_ = 1;
     319
     320                size_t c = std::max(q + 1, cap_order_taylor_);
     321                capacity_order(c, r);
     322        }
     323        CPPAD_ASSERT_UNKNOWN( cap_order_taylor_ > q );
     324        CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == r )
     325
     326        // short hand notation for order capacity
     327        size_t c = cap_order_taylor_;
     328
     329        // set Taylor coefficients for independent variables
     330        for(j = 0; j < n; j++)
     331        {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < num_var_tape_  );
     332
     333                // ind_taddr_[j] is operator taddr for j-th independent variable
     334                CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[j] ) == InvOp );
     335
     336                for(ell = 0; ell < r; ell++)
     337                {       size_t index = ((c-1)*r + 1)*ind_taddr_[j] + (q-1)*r + ell + 1;
     338                        taylor_[ index ] = xq[ r * j + ell ];
     339                }
     340        }
     341
     342        // evaluate the derivatives
     343        CPPAD_ASSERT_UNKNOWN( cskip_op_.size() == play_.num_op_rec() );
     344        CPPAD_ASSERT_UNKNOWN( load_op_.size()  == play_.num_load_op_rec() );
     345        forward2sweep(
     346                q,
     347                r,
     348                n,
     349                num_var_tape_,
     350                &play_,
     351                c,
     352                taylor_.data(),
     353                cskip_op_.data(),
     354                load_op_
     355        );
     356
     357        // return Taylor coefficients for dependent variables
     358        VectorBase yq;
     359        yq.resize(r * m);
     360        for(i = 0; i < m; i++)
     361        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_  );
     362                for(ell = 0; ell < r; ell++)
     363                {       size_t index = ((c-1)*r + 1)*dep_taddr_[i] + (q-1)*r + ell + 1;
     364                        yq[ r * i + ell ] = taylor_[ index ];
     365                }
     366        }
     367# ifndef NDEBUG
     368        if( check_for_nan_ )
     369        {       bool ok = true;
     370                for(i = 0; i < m; i++)
     371                {       for(ell = 0; ell < r; ell++)
     372                        {       // Studio 2012, CppAD required in front of isnan ?
     373                                ok &= ! CppAD::isnan( yq[ r * i + ell ] );
     374                        }
     375                }
     376                CPPAD_ASSERT_KNOWN(ok,
     377                "yq = f.Forward(q, r, xq): has a non-zero order Taylor coefficient\n"
     378                "with the value nan (but zero order coefficients are not nan)."
     379                );
     380        }
     381# endif
     382
     383        // now we have q + 1  taylor_ coefficient orders per variable
     384        num_order_taylor_ = q + 1;
     385
     386        return yq;
     387}
     388
    211389
    212390} // END_CPPAD_NAMESPACE
  • trunk/cppad/local/forward0sweep.hpp

    r3262 r3301  
    151151        size_t p = 0;
    152152        size_t q = 0;
     153        size_t r = 1;
    153154        /*
    154155        <!-- define forward0sweep_code_define -->
     
    209210        //
    210211        // next expected operator in a UserOp sequence
    211         enum { user_start, user_arg, user_ret, user_end } user_state = user_start;
     212        enum { user_start, user_arg, user_ret, user_end, user_trace }
     213        user_state = user_start;
    212214
    213215        // length of the parameter vector (used by CppAD assert macros)
     
    229231        <!-- end forward0sweep_code_define -->
    230232        */
     233
     234# if CPPAD_FORWARD0SWEEP_TRACE
     235        // variable indices for results vector
     236        // (done differently for order zero).
     237        vector<size_t> user_iy;     
     238# endif
    231239
    232240        // skip the BeginOp at the beginning of the recording
     
    347355
    348356                        case DisOp:
    349                         forward_dis_op_0(i_var, arg, J, taylor);
     357                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
    350358                        break;
    351359                        // -------------------------------------------------
     
    380388
    381389                        case InvOp:
     390                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    382391                        break;
    383392                        // -------------------------------------------------
     
    591600                                if(user_ty.size() != user_m)
    592601                                        user_ty.resize(user_m);
     602# if CPPAD_FORWARD0SWEEP_TRACE
     603                                if( user_iy.size() != user_m )
     604                                        user_iy.resize(user_m);
     605# endif
    593606                                user_j     = 0;
    594607                                user_i     = 0;
     
    609622                                }
    610623# endif
     624# if CPPAD_FORWARD0SWEEP_TRACE
     625                                user_state = user_trace;
     626# else
    611627                                user_state = user_start;
     628# endif
    612629                        }
    613630                        break;
     
    649666                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
    650667                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
     668# if CPPAD_FORWARD0SWEEP_TRACE
     669                        user_iy[user_i] = 0;
     670# endif
    651671                        user_i++;
    652672                        if( user_i == user_m )
     
    658678                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
    659679                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
     680# if CPPAD_FORWARD0SWEEP_TRACE
     681                        user_iy[user_i] = i_var;
     682# endif
    660683                        taylor[ i_var * J + 0 ] = user_ty[user_i++];
    661684                        if( user_i == user_m )
     
    668691                }
    669692# if CPPAD_FORWARD0SWEEP_TRACE
    670                 size_t          d      = 0;
    671                 size_t          i_tmp  = i_var;
    672                 Base*           Z_tmp  = taylor + i_var * J;
     693                size_t  d  = 0;
     694                if( user_state == user_trace )
     695                {       user_state = user_start;
     696
     697                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
     698                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
     699                        for(size_t i = 0; i < user_m; i++) if( user_iy[i] > 0 )
     700                        {       size_t i_tmp   = (i_op + i) - user_m;
     701                                printOp(
     702                                        std::cout,
     703                                        play,
     704                                        i_tmp,
     705                                        user_iy[i],
     706                                        UsrrvOp,
     707                                        CPPAD_NULL
     708                                );
     709                                Base* Z_tmp = taylor + user_iy[i] * J;
     710                                printOpResult(
     711                                        std::cout,
     712                                        d + 1,
     713                                        Z_tmp,
     714                                        0,
     715                                        (Base *) CPPAD_NULL
     716                                );
     717                                std::cout << std::endl;
     718                        }
     719                }
     720                Base*           Z_tmp   = taylor + i_var * J;
    673721                const addr_t*   arg_tmp = arg;
    674722                if( op == CSumOp )
     
    676724                if( op == CSkipOp )
    677725                        arg_tmp = arg - arg[-1] - 7;
    678                 //
    679                 printOp(
    680                         std::cout,
    681                         play,
    682                         i_op,
    683                         i_tmp,
    684                         op,
    685                         arg_tmp,
    686                         d + 1,
    687                         Z_tmp,
    688                         0,
    689                         (Base *) CPPAD_NULL
    690                 );
     726                if( op != UsrrvOp )
     727                {
     728                        printOp(
     729                                std::cout,
     730                                play,
     731                                i_op,
     732                                i_var,
     733                                op,
     734                                arg_tmp
     735                        );
     736                        if( NumRes(op) > 0 ) printOpResult(
     737                                std::cout,
     738                                d + 1,
     739                                Z_tmp,
     740                                0,
     741                                (Base *) CPPAD_NULL
     742                        );
     743                        std::cout << std::endl;
     744                }
    691745        }
    692746        std::cout << std::endl;
  • trunk/cppad/local/forward1sweep.hpp

    r3262 r3301  
    190190)
    191191{
     192        // number of directions
     193        const size_t r = 1;
     194
    192195        CPPAD_ASSERT_UNKNOWN( p <= q );
    193196        CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
     
    252255        //
    253256        // next expected operator in a UserOp sequence
    254         enum { user_start, user_arg, user_ret, user_end } user_state = user_start;
     257        enum { user_start, user_arg, user_ret, user_end, user_trace }
     258        user_state = user_start;
    255259
    256260        // length of the parameter vector (used by CppAD assert macros)
     
    401405
    402406                        case DisOp:
    403                         i = p;
    404                         if( i == 0 )
    405                         {       forward_dis_op_0(i_var, arg, J, taylor);
    406                                 i++;
    407                         }
    408                         while(i <= q)
    409                         {       taylor[ i_var * J + i] = Base(0);
    410                                 i++;
    411                         }
     407                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
    412408                        break;
    413409                        // -------------------------------------------------
     
    442438
    443439                        case InvOp:
    444                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
     440                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
    445441                        break;
    446442                        // -------------------------------------------------
     
    460456                                );
    461457                                if( p < q ) forward_load_op(
    462                                 op, p+1, q, i_var, arg, J, taylor, var_by_load_op.data()
    463                                 );
    464                         }
    465                         else    forward_load_op(
    466                                 op, p, q, i_var, arg, J, taylor, var_by_load_op.data()
     458                                        play,
     459                                        op,
     460                                        p+1,
     461                                        q,
     462                                        r,
     463                                        J,
     464                                        i_var,
     465                                        arg,
     466                                        var_by_load_op.data(),
     467                                        taylor
     468                                );
     469                        }
     470                        else    forward_load_op(
     471                                play,
     472                                op,
     473                                p,
     474                                q,
     475                                r,
     476                                J,
     477                                i_var,
     478                                arg,
     479                                var_by_load_op.data(),
     480                                taylor
    467481                        );
    468482                        break;
     
    482496                                        var_by_load_op.data()
    483497                                );
    484                                 if( p < q ) forward_load_op(
    485                                 op, p+1, q, i_var, arg, J, taylor, var_by_load_op.data()
     498                                if( p < q ) forward_load_op(
     499                                        play,
     500                                        op,
     501                                        p+1,
     502                                        q,
     503                                        r,
     504                                        J,
     505                                        i_var,
     506                                        arg,
     507                                        var_by_load_op.data(),
     508                                        taylor
    486509                                );
    487510                        }
    488511                        else    forward_load_op(
    489                         op, p, q, i_var, arg, J, taylor, var_by_load_op.data()
     512                                play,
     513                                op,
     514                                p,
     515                                q,
     516                                r,
     517                                J,
     518                                i_var,
     519                                arg,
     520                                var_by_load_op.data(),
     521                                taylor
    490522                        );
    491523                        break;
     
    717749                                                        taylor[ user_iy[i] * J + k ] =
    718750                                                                user_ty[ i * user_q1 + k ];
    719 
     751# if CPPAD_FORWARD1SWEEP_TRACE
     752                                user_state = user_trace;
     753# else
    720754                                user_state = user_start;
     755# endif
    721756                        }
    722757                        break;
     
    777812                }
    778813# if CPPAD_FORWARD1SWEEP_TRACE
    779                 size_t          i_tmp  = i_var;
    780                 Base*           Z_tmp  = taylor + J * i_var;
     814                if( user_state == user_trace )
     815                {       user_state = user_start;
     816
     817                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
     818                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
     819                        for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
     820                        {       size_t i_tmp   = (i_op + i) - user_m;
     821                                printOp(
     822                                        std::cout,
     823                                        play,
     824                                        i_tmp,
     825                                        user_iy[i],
     826                                        UsrrvOp,
     827                                        CPPAD_NULL
     828                                );
     829                                Base* Z_tmp = taylor + user_iy[i] * J;
     830                                printOpResult(
     831                                        std::cout,
     832                                        q + 1,
     833                                        Z_tmp,
     834                                        0,
     835                                        (Base *) CPPAD_NULL
     836                                );
     837                                std::cout << std::endl;
     838                        }
     839                }
     840                Base*           Z_tmp   = taylor + J * i_var;
    781841                const addr_t*   arg_tmp = arg;
    782842                if( op == CSumOp )
     
    784844                if( op == CSkipOp )
    785845                        arg_tmp = arg - arg[-1] - 7;
    786                 //
    787                 printOp(
    788                         std::cout,
    789                         play,
    790                         i_op,
    791                         i_tmp,
    792                         op,
    793                         arg_tmp,
    794                         q + 1,
    795                         Z_tmp,
    796                         0,
    797                         (Base *) CPPAD_NULL
    798                 );
     846                if( op != UsrrvOp )
     847                {
     848                        printOp(
     849                                std::cout,
     850                                play,
     851                                i_op,
     852                                i_var,
     853                                op,
     854                                arg_tmp
     855                        );
     856                        if( NumRes(op) > 0 ) printOpResult(
     857                                std::cout,
     858                                q + 1,
     859                                Z_tmp,
     860                                0,
     861                                (Base *) CPPAD_NULL
     862                        );
     863                        std::cout << std::endl;
     864                }
    799865        }
    800866        std::cout << std::endl;
  • trunk/cppad/local/fun_construct.hpp

    r3232 r3301  
    298298        num_order_taylor_          = f.num_order_taylor_;
    299299        cap_order_taylor_          = f.cap_order_taylor_;
     300        num_direction_taylor_      = f.num_direction_taylor_;
    300301        num_var_tape_              = f.num_var_tape_;
    301302        //
     
    432433        // allocate memory for one zero order taylor_ coefficient
    433434        CPPAD_ASSERT_UNKNOWN( num_order_taylor_ == 0 );
     435        CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == 0 );
    434436        size_t c = 1;
    435         capacity_order(c);
     437        size_t r = 1;
     438        capacity_order(c, r);
    436439        CPPAD_ASSERT_UNKNOWN( cap_order_taylor_     == c );
     440        CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == r );
    437441
    438442        // set zero order coefficients corresponding to indpendent variables
  • trunk/cppad/local/load_op.hpp

    r3232 r3301  
    6464i_vec is defined by
    6565\verbatim
    66         i_vec = floor( taylor[ arg[1] * nc_taylor + 0 ] )
     66        i_vec = floor( taylor[ arg[1] * cap_order + 0 ] )
    6767\endverbatim
    6868where floor(c) is the greatest integer less that or equal c.
     
    7777This vector has size play->num_par_rec().
    7878
    79 \param nc_taylor
     79\param cap_order
    8080number of columns in the matrix containing the Taylor coefficients.
    8181
     
    8484Input
    8585\n
    86 In LdvOp case, <code>taylor[ arg[1] * nc_taylor + 0 ]</code>
     86In LdvOp case, <code>taylor[ arg[1] * cap_order + 0 ]</code>
    8787is used to compute the index in the definition of i_vec above.
    88 If v[x] is a variable, <code>taylor[ i_v_x * nc_taylor + 0 ]</code>
     88If v[x] is a variable, <code>taylor[ i_v_x * cap_order + 0 ]</code>
    8989is the zero order Taylor coefficient for v[x].
    9090\n
     
    9292Output
    9393\n
    94 <code>taylor[ i_z * nc_taylor + 0 ]</code>
     94<code>taylor[ i_z * cap_order + 0 ]</code>
    9595is set to the zero order Taylor coefficient for the variable z.
    9696
     
    129129        const addr_t*  arg         ,
    130130        const Base*    parameter   ,
    131         size_t         nc_taylor   ,
     131        size_t         cap_order   ,
    132132        Base*          taylor      ,
    133133        bool*          isvar_by_ind   ,
     
    226226        const addr_t*  arg         ,
    227227        const Base*    parameter   ,
    228         size_t         nc_taylor   ,
     228        size_t         cap_order   ,
    229229        Base*          taylor      ,
    230230        bool*          isvar_by_ind   ,
     
    243243
    244244        size_t i_v_x  = index_by_ind[ arg[0] + i_vec ];
    245         Base* z       = taylor + i_z * nc_taylor;
     245        Base* z       = taylor + i_z * cap_order;
    246246        if( isvar_by_ind[ arg[0] + i_vec ]  )
    247247        {       CPPAD_ASSERT_UNKNOWN( i_v_x < i_z );
    248248                var_by_load_op[ arg[2] ] = i_v_x;
    249                 Base* v_x = taylor + i_v_x * nc_taylor;
     249                Base* v_x = taylor + i_v_x * cap_order;
    250250                z[0]      = v_x[0];
    251251        }
     
    269269        const addr_t*  arg         ,
    270270        const Base*    parameter   ,
    271         size_t         nc_taylor   ,
     271        size_t         cap_order   ,
    272272        Base*          taylor      ,
    273273        bool*          isvar_by_ind   ,
     
    280280        CPPAD_ASSERT_UNKNOWN( arg[2] < play->num_load_op_rec() );
    281281
    282         size_t i_vec = Integer( taylor[ arg[1] * nc_taylor + 0 ] );
     282        size_t i_vec = Integer( taylor[ arg[1] * cap_order + 0 ] );
    283283        CPPAD_ASSERT_KNOWN(
    284284                i_vec < index_by_ind[ arg[0] - 1 ] ,
     
    288288
    289289        size_t i_v_x  = index_by_ind[ arg[0] + i_vec ];
    290         Base* z       = taylor + i_z * nc_taylor;
     290        Base* z       = taylor + i_z * cap_order;
    291291        if( isvar_by_ind[ arg[0] + i_vec ]  )
    292292        {       CPPAD_ASSERT_UNKNOWN( i_v_x < i_z );
    293293                var_by_load_op[ arg[2] ] = i_v_x;
    294                 Base* v_x = taylor + i_v_x * nc_taylor;
     294                Base* v_x = taylor + i_v_x * cap_order;
    295295                z[0]      = v_x[0];
    296296        }
     
    316316using AD<Base> and computations by this routine are done using type Base.
    317317
     318\param play
     319is the tape that this operation appears in.
     320This is for error detection and not used when NDEBUG is defined.
     321
    318322\param op
    319323is the code corresponding to this operator; i.e., LdpOp or LdvOp
     
    326330is the highest order of the Taylor coefficient that we are computing.
    327331
     332\param r
     333is the number of directions for the Taylor coefficients that we
     334are computing.
     335
     336\param cap_order
     337number of columns in the matrix containing the Taylor coefficients.
     338
     339\par tpv
     340We use the notation
     341<code>tpv = (cap_order-1) * r + 1</code>
     342which is the number of Taylor coefficients per variable
     343
    328344\param i_z
    329345is the AD variable index corresponding to the variable z.
     
    331347\param arg
    332348arg[2]
    333 Is the index of this vecad load instruction in the
    334 var_by_load_op array.
    335 
    336 \param nc_taylor
    337 number of columns in the matrix containing the Taylor coefficients.
    338 
    339 \param taylor
    340 \n
    341 Input
    342 \n
    343 If v[x] is a variable, <code>taylor[ arg[2] * nc_taylor + k ]</code>
    344 for k = 0 , ... , q,
    345 is the k-order Taylor coefficient corresponding to v[x].
    346 \n
    347 \n
    348 Output
    349 \n
    350 <code>taylor[ i_z * nc_taylor + d ]</code>
    351 for k = p , ... , q,
    352 is set to the k-order Taylor coefficient for the variable z.
     349Is the index of this vecad load instruction in the var_by_load_op array.
    353350
    354351\param var_by_load_op
     
    357354In the case where the index is zero,
    358355the instruction corresponds to a parameter (not variable).
     356
     357\par i_var
     358We use the notation
     359\verbatim
     360        i_var = size_t( var_by_load_op[ arg[2] ] )
     361\endverbatim
     362
     363\param taylor
     364\n
     365Input
     366\n
     367If <code>i_var > 0</code>, v[x] is a variable and
     368for k = 1 , ... , q
     369<code>taylor[ i_var * tpv + (k-1)*r+1+ell ]</code>
     370is the k-th order coefficient for v[x] in the ell-th direction,
     371\n
     372\n
     373Output
     374\n
     375for k = p , ... , q,
     376<code>taylor[ i_z * tpv + (k-1)*r+1+ell ]</code>
     377is set to the k-order Taylor coefficient for z in the ell-th direction.
    359378*/
    360379template <class Base>
    361380inline void forward_load_op(
    362         OpCode         op          ,
    363         size_t         p           ,
    364         size_t         q           ,
    365         size_t         i_z         ,
    366         const addr_t*  arg         ,
    367         size_t         nc_taylor   ,
    368         Base*          taylor      ,
    369         const addr_t*        var_by_load_op )
    370 {       size_t i_load = size_t( var_by_load_op[ arg[2] ] );
    371 
     381        const player<Base>*  play                 ,
     382        OpCode               op                   ,
     383        size_t               p                    ,
     384        size_t               q                    ,
     385        size_t               r                    ,
     386        size_t               cap_order            ,
     387        size_t               i_z                  ,
     388        const addr_t*        arg                  ,
     389        const addr_t*        var_by_load_op       ,
     390              Base*          taylor               )
     391{       
    372392        CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
    373393        CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
    374         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
    375         CPPAD_ASSERT_UNKNOWN( 0 < p && p <= q );
    376         CPPAD_ASSERT_UNKNOWN( i_load < i_z );
    377 
    378         Base* z      = taylor + i_z * nc_taylor;
    379         if( i_load > 0 )
    380         {       Base* v_x = taylor + i_load * nc_taylor;
    381                 for(size_t d = p; d <= q; d++)
    382                         z[d] = v_x[d];
     394        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     395        CPPAD_ASSERT_UNKNOWN( 0 < r);
     396        CPPAD_ASSERT_UNKNOWN( 0 < p);
     397        CPPAD_ASSERT_UNKNOWN( p <= q );
     398        CPPAD_ASSERT_UNKNOWN( arg[2] < play->num_load_op_rec() );
     399
     400        size_t i_var = size_t( var_by_load_op[ arg[2] ] );
     401        CPPAD_ASSERT_UNKNOWN( i_var < i_z );
     402
     403        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     404        Base* z  = taylor + i_z * num_taylor_per_var;
     405        if( i_var > 0 )
     406        {       Base* v_x = taylor + i_var * num_taylor_per_var;
     407                for(size_t ell = 0; ell < r; ell++)
     408                {       for(size_t k = p; k <= q; k++)
     409                        {       size_t m = (k-1) * r + 1 + ell;
     410                                z[m]     = v_x[m];
     411                        }
     412                }
    383413        }
    384414        else
    385         {       for(size_t d = p; d <= q; d++)
    386                         z[d] = Base(0);
     415        {       for(size_t ell = 0; ell < r; ell++)
     416                {       for(size_t k = p; k <= q; k++)
     417                        {       size_t m = (k-1) * r + 1 + ell;
     418                                z[m]     = Base(0);
     419                        }
     420                }
    387421        }
    388422}
     
    425459var_by_load_op array.
    426460
    427 \param nc_taylor
     461\param cap_order
    428462number of columns in the matrix containing the Taylor coefficients
    429463(not used).
     
    465499\li NumArg(op) == 3
    466500\li NumRes(op) == 1
    467 \li d < nc_taylor
     501\li d < cap_order
    468502\li size_t(arg[2]) < i_z
    469503*/
     
    474508        size_t         i_z         ,
    475509        const addr_t*  arg         ,
    476         size_t         nc_taylor   ,
     510        size_t         cap_order   ,
    477511        const Base*    taylor      ,
    478512        size_t         nc_partial  ,
     
    483517        CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
    484518        CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
    485         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     519        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    486520        CPPAD_ASSERT_UNKNOWN( i_load < i_z );
    487521
  • trunk/cppad/local/log_op.hpp

    r3232 r3301  
    3636        size_t i_z         ,
    3737        size_t i_x         ,
    38         size_t nc_taylor   ,
     38        size_t cap_order   ,
    3939        Base*  taylor      )
    4040{       
     
    4545        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
    4646        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    47         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     47        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    4848        CPPAD_ASSERT_UNKNOWN( p <= q );
    4949
    5050        // Taylor coefficients corresponding to argument and result
    51         Base* x = taylor + i_x * nc_taylor;
    52         Base* z = taylor + i_z * nc_taylor;
     51        Base* x = taylor + i_x * cap_order;
     52        Base* z = taylor + i_z * cap_order;
    5353
    5454        if( p == 0 )
     
    7474
    7575/*!
     76Muiltiple directions Taylor coefficient for op = LogOp.
     77
     78The C++ source code corresponding to this operation is
     79\verbatim
     80        z = log(x)
     81\endverbatim
     82
     83\copydetails forward_unary1_op_dir
     84*/
     85template <class Base>
     86inline void forward_log_op_dir(
     87        size_t q           ,
     88        size_t r           ,
     89        size_t i_z         ,
     90        size_t i_x         ,
     91        size_t cap_order   ,
     92        Base*  taylor      )
     93{       
     94
     95        // check assumptions
     96        CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
     97        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
     98        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
     99        CPPAD_ASSERT_UNKNOWN( 0 < q );
     100        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     101
     102        // Taylor coefficients corresponding to argument and result
     103        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     104        Base* x = taylor + i_x * num_taylor_per_var;
     105        Base* z = taylor + i_z * num_taylor_per_var;
     106
     107        size_t m = (q-1) * r + 1;
     108        for(size_t ell = 0; ell < r; ell++)
     109        {       z[m+ell] = Base(q) * x[m+ell];
     110                for(size_t k = 1; k < q; k++)
     111                        z[m+ell] -= Base(k) * z[(k-1)*r+1+ell] * x[(q-k-1)*r+1+ell];
     112                z[m+ell] /= (Base(q) * x[0]);
     113        }       
     114}
     115
     116/*!
    76117Compute zero order forward mode Taylor coefficient for result of op = LogOp.
    77118
     
    87128        size_t i_z         ,
    88129        size_t i_x         ,
    89         size_t nc_taylor   ,
     130        size_t cap_order   ,
    90131        Base*  taylor      )
    91132{
     
    95136        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
    96137        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    97         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     138        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    98139
    99140        // Taylor coefficients corresponding to argument and result
    100         Base* x = taylor + i_x * nc_taylor;
    101         Base* z = taylor + i_z * nc_taylor;
     141        Base* x = taylor + i_x * cap_order;
     142        Base* z = taylor + i_z * cap_order;
    102143
    103144        z[0] = log( x[0] );
     
    120161        size_t      i_z          ,
    121162        size_t      i_x          ,
    122         size_t      nc_taylor    ,
     163        size_t      cap_order    ,
    123164        const Base* taylor       ,
    124165        size_t      nc_partial   ,
     
    130171        CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
    131172        CPPAD_ASSERT_UNKNOWN( i_x < i_z );
    132         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     173        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    133174        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    134175
    135176        // Taylor coefficients and partials corresponding to argument
    136         const Base* x  = taylor  + i_x * nc_taylor;
     177        const Base* x  = taylor  + i_x * cap_order;
    137178        Base* px       = partial + i_x * nc_partial;
    138179
    139180        // Taylor coefficients and partials corresponding to result
    140         const Base* z  = taylor  + i_z * nc_taylor;
     181        const Base* z  = taylor  + i_z * cap_order;
    141182        Base* pz       = partial + i_z * nc_partial;
    142183
  • trunk/cppad/local/mul_op.hpp

    r3232 r3301  
    4242        const addr_t* arg         ,
    4343        const Base*   parameter   ,
    44         size_t        nc_taylor   ,
     44        size_t        cap_order   ,
    4545        Base*         taylor      )
    4646{
     
    5050        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    5151        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    52         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     52        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5353        CPPAD_ASSERT_UNKNOWN( p <= q );
    5454
    5555        // Taylor coefficients corresponding to arguments and result
    56         Base* x = taylor + arg[0] * nc_taylor;
    57         Base* y = taylor + arg[1] * nc_taylor;
    58         Base* z = taylor + i_z    * nc_taylor;
     56        Base* x = taylor + arg[0] * cap_order;
     57        Base* y = taylor + arg[1] * cap_order;
     58        Base* z = taylor + i_z    * cap_order;
    5959
    6060        size_t k;
     
    6565        }
    6666}
    67 
    68 /*!
    69 Compute zero order forward mode Taylor coefficients for result of op = MulvvOp.
     67/*!
     68Multiple directions forward mode Taylor coefficients for op = MulvvOp.
    7069
    7170The C++ source code corresponding to this operation is
     
    7776and the argument \a parameter is not used.
    7877
    79 \copydetails forward_binary_op_0
    80 */
    81 
    82 template <class Base>
    83 inline void forward_mulvv_op_0(
    84         size_t        i_z         ,
    85         const addr_t* arg         ,
    86         const Base*   parameter   ,
    87         size_t        nc_taylor   ,
     78\copydetails forward_binary_op_dir
     79*/
     80
     81template <class Base>
     82inline void forward_mulvv_op_dir(
     83        size_t        q           ,
     84        size_t        r           ,
     85        size_t        i_z         ,
     86        const addr_t* arg         ,
     87        const Base*   parameter   ,
     88        size_t        cap_order   ,
    8889        Base*         taylor      )
    8990{
     
    9394        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    9495        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    95 
    96         // Taylor coefficients corresponding to arguments and result
    97         Base* x = taylor + arg[0] * nc_taylor;
    98         Base* y = taylor + arg[1] * nc_taylor;
    99         Base* z = taylor + i_z    * nc_taylor;
    100 
    101         z[0] = x[0] * y[0];
    102 }
    103 
    104 /*!
    105 Compute reverse mode partial derivatives for result of op = MulvvOp.
     96        CPPAD_ASSERT_UNKNOWN( 0 < q );
     97        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     98
     99        // Taylor coefficients corresponding to arguments and result
     100        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     101        Base* x = taylor + arg[0] * num_taylor_per_var;
     102        Base* y = taylor + arg[1] * num_taylor_per_var;
     103        Base* z = taylor +    i_z * num_taylor_per_var;
     104
     105        size_t k, ell, m;
     106        for(ell = 0; ell < r; ell++)
     107        {       m = (q-1)*r + ell + 1;
     108                z[m] = x[0] * y[m] + x[m] * y[0];
     109                for(k = 1; k < q; k++)
     110                        z[m] += x[(q-k-1)*r + ell + 1] * y[(k-1)*r + ell + 1];
     111        }
     112}
     113
     114/*!
     115Compute zero order forward mode Taylor coefficients for result of op = MulvvOp.
    106116
    107117The C++ source code corresponding to this operation is
     
    113123and the argument \a parameter is not used.
    114124
     125\copydetails forward_binary_op_0
     126*/
     127
     128template <class Base>
     129inline void forward_mulvv_op_0(
     130        size_t        i_z         ,
     131        const addr_t* arg         ,
     132        const Base*   parameter   ,
     133        size_t        cap_order   ,
     134        Base*         taylor      )
     135{
     136        // check assumptions
     137        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
     138        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
     139        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
     140        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     141
     142        // Taylor coefficients corresponding to arguments and result
     143        Base* x = taylor + arg[0] * cap_order;
     144        Base* y = taylor + arg[1] * cap_order;
     145        Base* z = taylor + i_z    * cap_order;
     146
     147        z[0] = x[0] * y[0];
     148}
     149
     150/*!
     151Compute reverse mode partial derivatives for result of op = MulvvOp.
     152
     153The C++ source code corresponding to this operation is
     154\verbatim
     155        z = x * y
     156\endverbatim
     157In the documentation below,
     158this operations is for the case where both x and y are variables
     159and the argument \a parameter is not used.
     160
    115161\copydetails reverse_binary_op
    116162*/
     
    122168        const addr_t* arg         ,
    123169        const Base*   parameter   ,
    124         size_t        nc_taylor   ,
     170        size_t        cap_order   ,
    125171        const Base*   taylor      ,
    126172        size_t        nc_partial  ,
     
    132178        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    133179        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    134         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     180        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    135181        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    136182
    137183        // Arguments
    138         const Base* x  = taylor + arg[0] * nc_taylor;
    139         const Base* y  = taylor + arg[1] * nc_taylor;
     184        const Base* x  = taylor + arg[0] * cap_order;
     185        const Base* y  = taylor + arg[1] * cap_order;
    140186
    141187        // Partial derivatives corresponding to arguments and result
     
    178224        const addr_t* arg         ,
    179225        const Base*   parameter   ,
    180         size_t        nc_taylor   ,
     226        size_t        cap_order   ,
    181227        Base*         taylor      )
    182228{
     
    185231        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
    186232        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    187         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     233        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    188234        CPPAD_ASSERT_UNKNOWN( p <= q );
    189235
    190236        // Taylor coefficients corresponding to arguments and result
    191         Base* y = taylor + arg[1] * nc_taylor;
    192         Base* z = taylor + i_z    * nc_taylor;
     237        Base* y = taylor + arg[1] * cap_order;
     238        Base* z = taylor + i_z    * cap_order;
    193239
    194240        // Paraemter value
     
    199245}
    200246/*!
    201 Compute zero order forward mode Taylor coefficient for result of op = MulpvOp.
     247Multiple directions forward mode Taylor coefficients for op = MulpvOp.
    202248
    203249The C++ source code corresponding to this operation is
     
    208254this operations is for the case where x is a parameter and y is a variable.
    209255
    210 \copydetails forward_binary_op_0
    211 */
    212 
    213 template <class Base>
    214 inline void forward_mulpv_op_0(
    215         size_t        i_z         ,
    216         const addr_t* arg         ,
    217         const Base*   parameter   ,
    218         size_t        nc_taylor   ,
     256\copydetails forward_binary_op_dir
     257*/
     258
     259template <class Base>
     260inline void forward_mulpv_op_dir(
     261        size_t        q           ,
     262        size_t        r           ,
     263        size_t        i_z         ,
     264        const addr_t* arg         ,
     265        const Base*   parameter   ,
     266        size_t        cap_order   ,
    219267        Base*         taylor      )
    220268{
     
    223271        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
    224272        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     273        CPPAD_ASSERT_UNKNOWN( 0 < q );
     274        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     275
     276        // Taylor coefficients corresponding to arguments and result
     277        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     278        size_t m                  = (q-1) * r + 1;
     279        Base* y = taylor + arg[1] * num_taylor_per_var + m;
     280        Base* z = taylor + i_z    * num_taylor_per_var + m;
    225281
    226282        // Paraemter value
    227283        Base x = parameter[ arg[0] ];
    228284
    229         // Taylor coefficients corresponding to arguments and result
    230         Base* y = taylor + arg[1] * nc_taylor;
    231         Base* z = taylor + i_z    * nc_taylor;
     285        for(size_t ell = 0; ell < r; ell++)
     286                z[ell] = x * y[ell];
     287}
     288/*!
     289Compute zero order forward mode Taylor coefficient for result of op = MulpvOp.
     290
     291The C++ source code corresponding to this operation is
     292\verbatim
     293        z = x * y
     294\endverbatim
     295In the documentation below,
     296this operations is for the case where x is a parameter and y is a variable.
     297
     298\copydetails forward_binary_op_0
     299*/
     300
     301template <class Base>
     302inline void forward_mulpv_op_0(
     303        size_t        i_z         ,
     304        const addr_t* arg         ,
     305        const Base*   parameter   ,
     306        size_t        cap_order   ,
     307        Base*         taylor      )
     308{
     309        // check assumptions
     310        CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
     311        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
     312        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     313
     314        // Paraemter value
     315        Base x = parameter[ arg[0] ];
     316
     317        // Taylor coefficients corresponding to arguments and result
     318        Base* y = taylor + arg[1] * cap_order;
     319        Base* z = taylor + i_z    * cap_order;
    232320
    233321        z[0] = x * y[0];
     
    253341        const addr_t* arg         ,
    254342        const Base*   parameter   ,
    255         size_t        nc_taylor   ,
     343        size_t        cap_order   ,
    256344        const Base*   taylor      ,
    257345        size_t        nc_partial  ,
     
    262350        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
    263351        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    264         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     352        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    265353        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    266354
  • trunk/cppad/local/op_code.hpp

    r3250 r3301  
    445445
    446446/*!
    447 Prints a single operator, its operands, and the corresponding result values.
     447Prints a single operator and its operands
    448448
    449449\tparam Base
    450450Is the base type for these AD< \a Base > operations.
    451451
    452 \tparam Value
    453 Determines the type of the values that we are printing.
    454 
    455452\param os
    456453is the output stream that the information is printed on.
    457454
    458 \param Rec
    459 2DO: change this name from Rec to play (becuase it is a player
    460 and not a recorder).
     455\param play
    461456Is the entire recording for the tape that this operator is in.
    462457
     
    466461\param i_var
    467462is the index for the variable corresponding to the result of this operation
    468 (ignored if NumRes(op) == 0).
     463(if NumRes(op) > 0).
    469464
    470465\param op
     
    474469is the vector of argument indices for this operation
    475470(must have NumArg(op) elements).
    476 
    477 \param nfz
    478 is the number of forward sweep calculated values of type Value
    479 that correspond to this operation
    480 (ignored if NumRes(op) == 0).
    481 
    482 \param fz
    483 points to the first forward calculated value
    484 that correspond to this operation
    485 (ignored if NumRes(op) == 0).
    486 
    487 \param nrz
    488 is the number of reverse sweep calculated values of type Value
    489 that correspond to this operation
    490 (ignored if NumRes(op) == 0).
    491 
    492 \param rz
    493 points to the first reverse calculated value
    494 that correspond to this operation
    495 (ignored if NumRes(op) == 0).
    496 
    497 \par 2DO
    498 print the operator index (in addition to the variables index).
    499471*/
    500 template <class Base, class Value>
     472template <class Base>
    501473void printOp(
    502         std::ostream          &os     ,
    503         const player<Base>   *Rec     ,
     474        std::ostream&          os     ,
     475        const player<Base>*    play   ,
    504476        size_t                 i_op   ,
    505477        size_t                 i_var  ,
    506478        OpCode                 op     ,
    507         const addr_t          *ind    ,
    508         size_t                 nfz    ,
    509         const  Value          *fz     ,
    510         size_t                 nrz    ,
    511         const  Value          *rz     )
     479        const addr_t*          ind    )
    512480{       size_t i;
    513481        CPPAD_ASSERT_KNOWN(
     
    520488        // print operator
    521489        printOpField(os,  "o=",      i_op,  5);
    522         printOpField(os,  "v=",      i_var, 5);
     490        if( NumRes(op) > 0 && op != BeginOp )
     491                printOpField(os,  "v=",      i_var, 5);
     492        else    printOpField(os,  "v=",      "",    5);
    523493        if( op == CExpOp || op == CSkipOp || op == ComOp )
    524494        {       printOpField(os, "", OpName(op), 5);
     
    548518                if( ind[1] & 1 )
    549519                        printOpField(os, " vl=", ind[2], ncol);
    550                 else    printOpField(os, " pl=", Rec->GetPar(ind[2]), ncol);
     520                else    printOpField(os, " pl=", play->GetPar(ind[2]), ncol);
    551521                if( ind[1] & 2 )
    552522                        printOpField(os, " vr=", ind[3], ncol);
    553                 else    printOpField(os, " pr=", Rec->GetPar(ind[3]), ncol);
     523                else    printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
    554524                if( size_t(ind[4]) < 3 )
    555525                {       for(i = 0; i < size_t(ind[4]); i++)
     
    583553                */
    584554                CPPAD_ASSERT_UNKNOWN( ind[3+ind[0]+ind[1]] == ind[0]+ind[1] );
    585                 printOpField(os, " pr=", Rec->GetPar(ind[2]), ncol);
     555                printOpField(os, " pr=", play->GetPar(ind[2]), ncol);
    586556                for(i = 0; i < size_t(ind[0]); i++)
    587557                         printOpField(os, " +v=", ind[3+i], ncol);
     
    606576                printOpField(os, "off=", ind[0], ncol);
    607577                printOpField(os, "idx=", ind[1], ncol);
    608                 printOpField(os, " pr=", Rec->GetPar(ind[2]), ncol);
     578                printOpField(os, " pr=", play->GetPar(ind[2]), ncol);
    609579                break;
    610580
     
    620590                printOpField(os, "off=", ind[0], ncol);
    621591                printOpField(os, " vl=", ind[1], ncol);
    622                 printOpField(os, " pr=", Rec->GetPar(ind[2]), ncol);
     592                printOpField(os, " pr=", play->GetPar(ind[2]), ncol);
    623593                break;
    624594
     
    646616                case DivpvOp:
    647617                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    648                 printOpField(os, " pl=", Rec->GetPar(ind[0]), ncol);
     618                printOpField(os, " pl=", play->GetPar(ind[0]), ncol);
    649619                printOpField(os, " vr=", ind[1], ncol);
    650620                break;
     
    655625                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    656626                printOpField(os, " vl=", ind[0], ncol);
    657                 printOpField(os, " pr=", Rec->GetPar(ind[1]), ncol);
     627                printOpField(os, " pr=", play->GetPar(ind[1]), ncol);
    658628                break;
    659629
     
    681651                case UsrrpOp:
    682652                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    683                 printOpField(os, "  p=", Rec->GetPar(ind[0]), ncol);
     653                printOpField(os, "  p=", play->GetPar(ind[0]), ncol);
    684654                break;
    685655
     
    698668                if( ind[0] & 1 )
    699669                        printOpField(os, " v=", ind[1], ncol);
    700                 else    printOpField(os, " p=", Rec->GetPar(ind[1]), ncol);
    701                 os << "before=\"" << Rec->GetTxt(ind[2]) << "\"";
     670                else    printOpField(os, " p=", play->GetPar(ind[1]), ncol);
     671                os << "before=\"" << play->GetTxt(ind[2]) << "\"";
    702672                if( ind[0] & 2 )
    703673                        printOpField(os, " v=", ind[3], ncol);
    704                 else    printOpField(os, " p=", Rec->GetPar(ind[3]), ncol);
    705                 os << "after=\"" << Rec->GetTxt(ind[4]) << "\"";
     674                else    printOpField(os, " p=", play->GetPar(ind[3]), ncol);
     675                os << "after=\"" << play->GetTxt(ind[4]) << "\"";
    706676                break;
    707677
     
    731701                if( ind[1] & 1 )
    732702                        printOpField(os, " vl=", ind[2], ncol);
    733                 else    printOpField(os, " pl=", Rec->GetPar(ind[2]), ncol);
     703                else    printOpField(os, " pl=", play->GetPar(ind[2]), ncol);
    734704                if( ind[1] & 2 )
    735705                        printOpField(os, " vr=", ind[3], ncol);
    736                 else    printOpField(os, " pr=", Rec->GetPar(ind[3]), ncol);
     706                else    printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
    737707                if( ind[1] & 4 )
    738708                        printOpField(os, " vt=", ind[4], ncol);
    739                 else    printOpField(os, " pt=", Rec->GetPar(ind[4]), ncol);
     709                else    printOpField(os, " pt=", play->GetPar(ind[4]), ncol);
    740710                if( ind[1] & 8 )
    741711                        printOpField(os, " vf=", ind[5], ncol);
    742                 else    printOpField(os, " pf=", Rec->GetPar(ind[5]), ncol);
     712                else    printOpField(os, " pf=", play->GetPar(ind[5]), ncol);
    743713                break;
    744714
     
    751721                if( ind[1] & 2 )
    752722                        printOpField(os, " vl=", ind[2], ncol);
    753                 else    printOpField(os, " pl=", Rec->GetPar(ind[2]), ncol);
     723                else    printOpField(os, " pl=", play->GetPar(ind[2]), ncol);
    754724                if( ind[1] & 4 )
    755725                        printOpField(os, " vr=", ind[3], ncol);
    756                 else    printOpField(os, " pr=", Rec->GetPar(ind[3]), ncol);
     726                else    printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
    757727                break;
    758728
     
    760730                CPPAD_ASSERT_UNKNOWN(0);
    761731        }
     732}
     733
     734/*!
     735Prints the result values correspnding to an operator.
     736
     737\tparam Base
     738Is the base type for these AD< \a Base > operations.
     739
     740\tparam Value
     741Determines the type of the values that we are printing.
     742
     743\param os
     744is the output stream that the information is printed on.
     745
     746\param nfz
     747is the number of forward sweep calculated values of type Value
     748that correspond to this operation
     749(ignored if NumRes(op) == 0).
     750
     751\param fz
     752points to the first forward calculated value
     753that correspond to this operation
     754(ignored if NumRes(op) == 0).
     755
     756\param nrz
     757is the number of reverse sweep calculated values of type Value
     758that correspond to this operation
     759(ignored if NumRes(op) == 0).
     760
     761\param rz
     762points to the first reverse calculated value
     763that correspond to this operation
     764(ignored if NumRes(op) == 0).
     765*/
     766template <class Value>
     767void printOpResult(
     768        std::ostream          &os     ,
     769        size_t                 nfz    ,
     770        const  Value          *fz     ,
     771        size_t                 nrz    ,
     772        const  Value          *rz     )
     773{
    762774        size_t k;
    763         if( NumRes(op) > 0 && (op != BeginOp) )
    764         {
    765                 for(k = 0; k < nfz; k++)
    766                         std::cout << "| fz[" << k << "]=" << fz[k];
    767                 for(k = 0; k < nrz; k++)
    768                         std::cout << "| rz[" << k << "]=" << rz[k];
    769         }
    770         std::cout << std::endl;
     775        for(k = 0; k < nfz; k++)
     776                os << "| fz[" << k << "]=" << fz[k];
     777        for(k = 0; k < nrz; k++)
     778                os << "| rz[" << k << "]=" << rz[k];
    771779}
    772780
  • trunk/cppad/local/parameter_op.hpp

    r3232 r3301  
    5454of y that is a parameter.
    5555
    56 \param nc_taylor
     56\param cap_order
    5757number of colums in the matrix containing all the Taylor coefficients.
    5858
    5959\param taylor
    60 \b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
     60\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
    6161is the zero order Taylor coefficient corresponding to z.
    6262
     
    6565\li NumRes(op) == 1
    6666\li \a size_t(arg[0]) < num_par
    67 \li \a 0 < \a nc_taylor
     67\li \a 0 < \a cap_order
    6868*/
    6969template <class Base>
     
    7373        size_t        num_par     ,
    7474        const Base*   parameter   ,
    75         size_t        nc_taylor   ,
     75        size_t        cap_order   ,
    7676        Base*         taylor      )
    7777{       
     
    8080        CPPAD_ASSERT_UNKNOWN( NumRes(ParOp) == 1 );
    8181        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    82         CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
     82        CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
    8383
    84         Base* z = taylor + i_z * nc_taylor;
     84        Base* z = taylor + i_z * cap_order;
    8585
    8686        z[0]  = parameter[ arg[0] ];
  • trunk/cppad/local/pow_op.hpp

    r3232 r3301  
    3838        const addr_t* arg         ,
    3939        const Base*   parameter   ,
    40         size_t        nc_taylor   ,
     40        size_t        cap_order   ,
    4141        Base*         taylor      )
    4242{
     
    4949        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    5050        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    51         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     51        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    5252        CPPAD_ASSERT_UNKNOWN( p <= q );
    5353
    5454        // z_0 = log(x)
    55         forward_log_op(p, q, i_z, arg[0], nc_taylor, taylor);
     55        forward_log_op(p, q, i_z, arg[0], cap_order, taylor);
    5656
    5757        // z_1 = z_0 * y
     
    5959        adr[0] = i_z;
    6060        adr[1] = arg[1];
    61         forward_mulvv_op(p, q, i_z+1, adr, parameter, nc_taylor, taylor);
     61        forward_mulvv_op(p, q, i_z+1, adr, parameter, cap_order, taylor);
    6262
    6363        // z_2 = exp(z_1)
     
    6565        if( p == 0 )
    6666        {       // Taylor coefficients corresponding to arguments and result
    67                 Base* x   = taylor + arg[0]  * nc_taylor;
    68                 Base* y   = taylor + arg[1]  * nc_taylor;
    69                 Base* z_2 = taylor + (i_z+2) * nc_taylor;
     67                Base* x   = taylor + arg[0]  * cap_order;
     68                Base* y   = taylor + arg[1]  * cap_order;
     69                Base* z_2 = taylor + (i_z+2) * cap_order;
    7070
    7171                z_2[0] = pow(x[0], y[0]);
     
    7373        }
    7474        if( p <= q )
    75                 forward_exp_op(p, q, i_z+2, i_z+1, nc_taylor, taylor);
    76 }
    77 
     75                forward_exp_op(p, q, i_z+2, i_z+1, cap_order, taylor);
     76}
     77/*!
     78Multiple directions forward mode Taylor coefficients for op = PowvvOp.
     79
     80The C++ source code corresponding to this operation is
     81\verbatim
     82        z = pow(x, y)
     83\endverbatim
     84In the documentation below,
     85this operations is for the case where x is a variable and y is a parameter.
     86
     87\copydetails forward_pow_op_dir
     88*/
     89
     90template <class Base>
     91inline void forward_powvv_op_dir(
     92        size_t        q           ,
     93        size_t        r           ,
     94        size_t        i_z         ,
     95        const addr_t* arg         ,
     96        const Base*   parameter   ,
     97        size_t        cap_order   ,
     98        Base*         taylor      )
     99{
     100        // convert from final result to first result
     101        i_z -= 2; // 2 = NumRes(PowvvOp) - 1
     102
     103        // check assumptions
     104        CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
     105        CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
     106        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
     107        CPPAD_ASSERT_UNKNOWN( 0 < q );
     108        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     109
     110        // z_0 = log(x)
     111        forward_log_op_dir(q, r, i_z, arg[0], cap_order, taylor);
     112
     113        // z_1 = y * z_0
     114        addr_t adr[2];
     115        adr[0] = i_z;
     116        adr[1] = arg[1];
     117        forward_mulvv_op_dir(q, r, i_z+1, adr, parameter, cap_order, taylor);
     118
     119        // z_2 = exp(z_1)
     120        forward_exp_op_dir(q, r, i_z+2, i_z+1, cap_order, taylor);
     121}
    78122/*!
    79123Compute zero order forward mode Taylor coefficients for result of op = PowvvOp.
     
    95139        const addr_t* arg         ,
    96140        const Base*   parameter   ,
    97         size_t        nc_taylor   ,
     141        size_t        cap_order   ,
    98142        Base*         taylor      )
    99143{
     
    108152
    109153        // Taylor coefficients corresponding to arguments and result
    110         Base* x   = taylor + arg[0] * nc_taylor;
    111         Base* y   = taylor + arg[1] * nc_taylor;
    112         Base* z_0 = taylor + i_z    * nc_taylor;
    113         Base* z_1 = z_0    +          nc_taylor;
    114         Base* z_2 = z_1    +          nc_taylor;
     154        Base* x   = taylor + arg[0] * cap_order;
     155        Base* y   = taylor + arg[1] * cap_order;
     156        Base* z_0 = taylor + i_z    * cap_order;
     157        Base* z_1 = z_0    +          cap_order;
     158        Base* z_2 = z_1    +          cap_order;
    115159
    116160        z_0[0] = log( x[0] );
     
    140184        const addr_t* arg         ,
    141185        const Base*   parameter   ,
    142         size_t        nc_taylor   ,
     186        size_t        cap_order   ,
    143187        const Base*   taylor      ,
    144188        size_t        nc_partial  ,
     
    153197        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    154198        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    155         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     199        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    156200        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    157201
    158202        // z_2 = exp(z_1)
    159203        reverse_exp_op(
    160                 d, i_z+2, i_z+1, nc_taylor, taylor, nc_partial, partial
     204                d, i_z+2, i_z+1, cap_order, taylor, nc_partial, partial
    161205        );
    162206
     
    166210        adr[1] = arg[1];
    167211        reverse_mulvv_op(
    168         d, i_z+1, adr, parameter, nc_taylor, taylor, nc_partial, partial
     212        d, i_z+1, adr, parameter, cap_order, taylor, nc_partial, partial
    169213        );
    170214
    171215        // z_0 = log(x)
    172216        reverse_log_op(
    173                 d, i_z, arg[0], nc_taylor, taylor, nc_partial, partial
     217                d, i_z, arg[0], cap_order, taylor, nc_partial, partial
    174218        );
    175219}
     
    196240        const addr_t* arg         ,
    197241        const Base*   parameter   ,
    198         size_t        nc_taylor   ,
     242        size_t        cap_order   ,
    199243        Base*         taylor      )
    200244{
     
    206250        CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
    207251        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    208         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     252        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    209253        CPPAD_ASSERT_UNKNOWN( p <= q );
    210254
    211255        // Taylor coefficients corresponding to arguments and result
    212         Base* z_0 = taylor + i_z    * nc_taylor;
     256        Base* z_0 = taylor + i_z    * cap_order;
    213257
    214258        // z_0 = log(x)
     
    223267        // z_1 = z_0 * y
    224268        addr_t adr[2];
    225         adr[0] = i_z * nc_taylor; // offset of z_0 in taylor; i.e., log(x)
    226         adr[1] = arg[1];          // variable index of y in taylor
    227 
    228         // use taylor both for parameter and variable values (trick)
    229         forward_mulpv_op(p, q, i_z+1, adr, taylor, nc_taylor, taylor);
     269        // offset of z_i in taylor (as if it were a parameter); i.e., log(x)
     270        adr[0] = i_z * cap_order;
     271        // offset of y in taylor (as a variable)
     272        adr[1] = arg[1];
     273
     274        // Trick: use taylor both for the parameter vector and variable values
     275        forward_mulpv_op(p, q, i_z+1, adr, taylor, cap_order, taylor);
    230276
    231277        // z_2 = exp(z_1)
    232278        // zero order case exactly same as Base type operation
    233279        if( p == 0 )
    234         {       Base* y   = taylor + arg[1]  * nc_taylor;
    235                 Base* z_2 = taylor + (i_z+2) * nc_taylor;
     280        {       Base* y   = taylor + arg[1]  * cap_order;
     281                Base* z_2 = taylor + (i_z+2) * cap_order;
    236282                z_2[0] = pow(x, y[0]);
    237283                p++;
    238284        }
    239285        if( p <= q )
    240                 forward_exp_op(p, q, i_z+2, i_z+1, nc_taylor, taylor);
    241 }
    242 /*!
    243 Compute zero order forward mode Taylor coefficient for result of op = PowpvOp.
     286                forward_exp_op(p, q, i_z+2, i_z+1, cap_order, taylor);
     287}
     288/*!
     289Multiple directions forward mode Taylor coefficients for op = PowpvOp.
    244290
    245291The C++ source code corresponding to this operation is
     
    250296this operations is for the case where x is a parameter and y is a variable.
    251297
    252 \copydetails forward_pow_op_0
    253 */
    254 
    255 template <class Base>
    256 inline void forward_powpv_op_0(
    257         size_t        i_z         ,
    258         const addr_t* arg         ,
    259         const Base*   parameter   ,
    260         size_t        nc_taylor   ,
    261         Base*         taylor      )
    262 {
    263         // convert from final result to first result
    264         i_z -= 2; // NumRes(PowpvOp) - 1;
     298\copydetails forward_pow_op_dir
     299*/
     300
     301template <class Base>
     302inline void forward_powpv_op_dir(
     303        size_t        q           ,
     304        size_t        r           ,
     305        size_t        i_z         ,
     306        const addr_t* arg         ,
     307        const Base*   parameter   ,
     308        size_t        cap_order   ,
     309        Base*         taylor      )
     310{       
     311        // convert from final result to first result
     312        i_z -= 2; // 2 = NumRes(PowpvOp) - 1;
    265313
    266314        // check assumptions
     
    268316        CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
    269317        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
     318        CPPAD_ASSERT_UNKNOWN( 0 < q );
     319        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     320
     321        // Taylor coefficients corresponding to arguments and result
     322        size_t num_taylor_per_var = (cap_order-1) * r + 1;
     323        Base* z_0 = taylor + i_z * num_taylor_per_var;
     324
     325        // z_0 = log(x)
     326        size_t m  = (q-1) * r + 1;
     327        for(size_t ell = 0; ell < r; ell++)
     328                z_0[m+ell] = Base(0);
     329
     330        // z_1 = z_0 * y
     331        addr_t adr[2];
     332        // offset of z_0 in taylor (as if it were a parameter); i.e., log(x)
     333        adr[0] = i_z * num_taylor_per_var;
     334        // ofset of y in taylor (as a variable)
     335        adr[1] = arg[1];
     336
     337        // Trick: use taylor both for the parameter vector and variable values
     338        forward_mulpv_op_dir(q, r, i_z+1, adr, taylor, cap_order, taylor);
     339
     340        // z_2 = exp(z_1)
     341        forward_exp_op_dir(q, r, i_z+2, i_z+1, cap_order, taylor);
     342}
     343/*!
     344Compute zero order forward mode Taylor coefficient for result of op = PowpvOp.
     345
     346The C++ source code corresponding to this operation is
     347\verbatim
     348        z = pow(x, y)
     349\endverbatim
     350In the documentation below,
     351this operations is for the case where x is a parameter and y is a variable.
     352
     353\copydetails forward_pow_op_0
     354*/
     355
     356template <class Base>
     357inline void forward_powpv_op_0(
     358        size_t        i_z         ,
     359        const addr_t* arg         ,
     360        const Base*   parameter   ,
     361        size_t        cap_order   ,
     362        Base*         taylor      )
     363{
     364        // convert from final result to first result
     365        i_z -= 2; // NumRes(PowpvOp) - 1;
     366
     367        // check assumptions
     368        CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
     369        CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
     370        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    270371
    271372        // Paraemter value
     
    273374
    274375        // Taylor coefficients corresponding to arguments and result
    275         Base* y   = taylor + arg[1] * nc_taylor;
    276         Base* z_0 = taylor + i_z    * nc_taylor;
    277         Base* z_1 = z_0    +          nc_taylor;
    278         Base* z_2 = z_1    +          nc_taylor;
     376        Base* y   = taylor + arg[1] * cap_order;
     377        Base* z_0 = taylor + i_z    * cap_order;
     378        Base* z_1 = z_0    +          cap_order;
     379        Base* z_2 = z_1    +          cap_order;
    279380
    280381        // z_0 = log(x)
     
    308409        const addr_t* arg         ,
    309410        const Base*   parameter   ,
    310         size_t        nc_taylor   ,
     411        size_t        cap_order   ,
    311412        const Base*   taylor      ,
    312413        size_t        nc_partial  ,
     
    320421        CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
    321422        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
    322         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     423        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    323424        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    324425
    325426        // z_2 = exp(z_1)
    326427        reverse_exp_op(
    327                 d, i_z+2, i_z+1, nc_taylor, taylor, nc_partial, partial
     428                d, i_z+2, i_z+1, cap_order, taylor, nc_partial, partial
    328429        );
    329430
    330431        // z_1 = z_0 * y
    331432        addr_t adr[2];
    332         adr[0] = i_z * nc_taylor; // offset of z_0[0] in taylor
     433        adr[0] = i_z * cap_order; // offset of z_0[0] in taylor
    333434        adr[1] = arg[1];          // index of y in taylor and partial
    334435        // use taylor both for parameter and variable values
    335436        reverse_mulpv_op(
    336                 d, i_z+1, adr, taylor, nc_taylor, taylor, nc_partial, partial
     437                d, i_z+1, adr, taylor, cap_order, taylor, nc_partial, partial
    337438        );
    338439
     
    343444// --------------------------- Powvp -----------------------------------------
    344445/*!
    345 Compute forward mode Taylor coefficients for result of op = PowvvOp.
     446Compute forward mode Taylor coefficients for result of op = PowvpOp.
    346447
    347448The C++ source code corresponding to this operation is
     
    362463        const addr_t* arg         ,
    363464        const Base*   parameter   ,
    364         size_t        nc_taylor   ,
     465        size_t        cap_order   ,
    365466        Base*         taylor      )
    366467{
     
    372473        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    373474        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    374         CPPAD_ASSERT_UNKNOWN( q < nc_taylor );
     475        CPPAD_ASSERT_UNKNOWN( q < cap_order );
    375476        CPPAD_ASSERT_UNKNOWN( p <= q );
    376477
    377478        // z_0 = log(x)
    378         forward_log_op(p, q, i_z, arg[0], nc_taylor, taylor);
     479        forward_log_op(p, q, i_z, arg[0], cap_order, taylor);
    379480
    380481        // z_1 = y * z_0
     
    382483        adr[0] = arg[1];
    383484        adr[1] = i_z;
    384         forward_mulpv_op(p, q, i_z+1, adr, parameter, nc_taylor, taylor);
     485        forward_mulpv_op(p, q, i_z+1, adr, parameter, cap_order, taylor);
    385486
    386487        // z_2 = exp(z_1)
    387488        // zero order case exactly same as Base type operation
    388489        if( p == 0 )
    389         {       Base* z_2 = taylor + (i_z+2) * nc_taylor;
    390                 Base* x   = taylor + arg[0] * nc_taylor;
     490        {       Base* z_2 = taylor + (i_z+2) * cap_order;
     491                Base* x   = taylor + arg[0] * cap_order;
    391492                Base  y   = parameter[ arg[1] ];
    392493                z_2[0]  = pow(x[0], y);
     
    394495        }
    395496        if( p <= q )
    396                 forward_exp_op(p, q, i_z+2, i_z+1, nc_taylor, taylor);
    397 }
    398 
    399 /*!
    400 Compute zero order forward mode Taylor coefficients for result of op = PowvvOp.
     497                forward_exp_op(p, q, i_z+2, i_z+1, cap_order, taylor);
     498}
     499/*!
     500Multiple directions forward mode Taylor coefficients for op = PowvpOp.
    401501
    402502The C++ source code corresponding to this operation is
     
    407507this operations is for the case where x is a variable and y is a parameter.
    408508
    409 \copydetails forward_pow_op_0
    410 */
    411 
    412 template <class Base>
    413 inline void forward_powvp_op_0(
    414         size_t        i_z         ,
    415         const addr_t* arg         ,
    416         const Base*   parameter   ,
    417         size_t        nc_taylor   ,
    418         Base*         taylor      )
    419 {
    420         // convert from final result to first result
    421         i_z -= 2; // NumRes(PowvpOp) - 1;
     509\copydetails forward_pow_op_dir
     510*/
     511
     512template <class Base>
     513inline void forward_powvp_op_dir(
     514        size_t        q           ,
     515        size_t        r           ,
     516        size_t        i_z         ,
     517        const addr_t* arg         ,
     518        const Base*   parameter   ,
     519        size_t        cap_order   ,
     520        Base*         taylor      )
     521{
     522        // convert from final result to first result
     523        i_z -= 2; // 2 = NumRes(PowvpOp) - 1
    422524
    423525        // check assumptions
     
    425527        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    426528        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
     529        CPPAD_ASSERT_UNKNOWN( 0 < q );
     530        CPPAD_ASSERT_UNKNOWN( q < cap_order );
     531
     532        // z_0 = log(x)
     533        forward_log_op_dir(q, r, i_z, arg[0], cap_order, taylor);
     534
     535        // z_1 = y * z_0
     536        addr_t adr[2];
     537        adr[0] = arg[1];
     538        adr[1] = i_z;
     539        forward_mulpv_op_dir(q, r, i_z+1, adr, parameter, cap_order, taylor);
     540
     541        // z_2 = exp(z_1)
     542        forward_exp_op_dir(q, r, i_z+2, i_z+1, cap_order, taylor);
     543}
     544
     545/*!
     546Compute zero order forward mode Taylor coefficients for result of op = PowvpOp.
     547
     548The C++ source code corresponding to this operation is
     549\verbatim
     550        z = pow(x, y)
     551\endverbatim
     552In the documentation below,
     553this operations is for the case where x is a variable and y is a parameter.
     554
     555\copydetails forward_pow_op_0
     556*/
     557
     558template <class Base>
     559inline void forward_powvp_op_0(
     560        size_t        i_z         ,
     561        const addr_t* arg         ,
     562        const Base*   parameter   ,
     563        size_t        cap_order   ,
     564        Base*         taylor      )
     565{
     566        // convert from final result to first result
     567        i_z -= 2; // NumRes(PowvpOp) - 1;
     568
     569        // check assumptions
     570        CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
     571        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
     572        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    427573
    428574        // Paraemter value
     
    430576
    431577        // Taylor coefficients corresponding to arguments and result
    432         Base* x   = taylor + arg[0] * nc_taylor;
    433         Base* z_0 = taylor + i_z    * nc_taylor;
    434         Base* z_1 = z_0    +          nc_taylor;
    435         Base* z_2 = z_1    +          nc_taylor;
     578        Base* x   = taylor + arg[0] * cap_order;
     579        Base* z_0 = taylor + i_z    * cap_order;
     580        Base* z_1 = z_0    +          cap_order;
     581        Base* z_2 = z_1    +          cap_order;
    436582
    437583        // z_0 = log(x)
     
    465611        const addr_t* arg         ,
    466612        const Base*   parameter   ,
    467         size_t        nc_taylor   ,
     613        size_t        cap_order   ,
    468614        const Base*   taylor      ,
    469615        size_t        nc_partial  ,
     
    477623        CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
    478624        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
    479         CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
     625        CPPAD_ASSERT_UNKNOWN( d < cap_order );
    480626        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
    481627
    482628        // z_2 = exp(z_1)
    483629        reverse_exp_op(
    484                 d, i_z+2, i_z+1, nc_taylor, taylor, nc_partial, partial
     630                d, i_z+2, i_z+1, cap_order, taylor, nc_partial, partial
    485631        );
    486632
     
    490636        adr[1] = i_z;
    491637        reverse_mulpv_op(
    492         d, i_z+1, adr, parameter, nc_taylor, taylor, nc_partial, partial
     638        d, i_z+1, adr, parameter, cap_order, taylor, nc_partial, partial
    493639        );
    494640
    495641        // z_0 = log(x)
    496642        reverse_log_op(
    497                 d, i_z, arg[0], nc_taylor, taylor, nc_partial, partial
     643                d, i_z, arg[0], cap_order, taylor, nc_partial, partial
    498644        );
    499645}
  • trunk/cppad/local/print_op.hpp

    r2910 r3301  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5353\n
    5454If \a pos is a parameter, <code>parameter[arg[1]]</code> is its value.
    55 Othwise <code>taylor[ arg[1] * nc_taylor + 0 ]</code> is the zero
     55Othwise <code>taylor[ arg[1] * cap_order + 0 ]</code> is the zero
    5656order Taylor coefficient for \a pos.
    5757\n
     
    6666\n
    6767If \a var is a parameter, <code>parameter[arg[3]]</code> is its value.
    68 Othwise <code>taylor[ arg[3] * nc_taylor + 0 ]</code> is the zero
     68Othwise <code>taylor[ arg[3] * cap_order + 0 ]</code> is the zero
    6969order Taylor coefficient for \a var.
    7070\n
     
    9090Contains the value of parameters.
    9191
    92 \param nc_taylor
     92\param cap_order
    9393number of colums in the matrix containing all the Taylor coefficients.
    9494
     
    113113        size_t        num_par     ,
    114114        const Base*   parameter   ,
    115         size_t        nc_taylor   ,
     115        size_t        cap_order   ,
    116116        const Base*   taylor      )
    117117{       Base pos, var;
     
    123123        if( arg[0] & 1 )
    124124        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= i_z );
    125                 pos = taylor[ arg[1] * nc_taylor + 0 ];
     125                pos = taylor[ arg[1] * cap_order + 0 ];
    126126        }
    127127        else
     
    137137        if( arg[0] & 2 )
    138138        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= i_z );
    139                 var = taylor[ arg[3] * nc_taylor + 0 ];
     139                var = taylor[ arg[3] * cap_order + 0 ];
    140140        }
    141141        else
  • trunk/cppad/local/prototype_op.hpp

    r3232 r3301  
    4646i.e. the row index in \a taylor corresponding to x.
    4747
    48 \param nc_taylor
    49 number of colums in the matrix containing all the Taylor coefficients.
    50 
    51 \param taylor
    52 \b Input: <code>taylor [ i_x * nc_taylor + k ]</code>,
     48\param cap_order
     49maximum number of orders that will fit in the \c taylor array.
     50
     51\param taylor
     52\b Input: <code>taylor [ i_x * cap_order + k ]</code>,
    5353for k = 0 , ... , q,
    5454is the k-th order Taylor coefficient corresponding to x.
    5555\n
    56 \b Input: <code>taylor [ i_z * nc_taylor + k ]</code>,
     56\b Input: <code>taylor [ i_z * cap_order + k ]</code>,
    5757for k = 0 , ... , p-1,
    5858is the k-th order Taylor coefficient corresponding to z.
    5959\n
    60 \b Output: <code>taylor [ i_z * nc_taylor + k ]</code>,
     60\b Output: <code>taylor [ i_z * cap_order + k ]</code>,
    6161for k = p , ... , q,
    6262is the k-th order Taylor coefficient corresponding to z.
     
    6666\li NumRes(op) == 1
    6767\li i_x < i_z
    68 \li q < nc_taylor
     68\li q < cap_order
    6969\li p <= q
    7070*/
     
    7575        size_t i_z         ,
    7676        size_t i_x         ,
    77         size_t nc_taylor   ,
     77        size_t cap_order   ,
    7878        Base*  taylor      )
    7979{
     
    8383
    8484/*!
    85 Prototype for zero order forward mode unary operator with one result (not used).
    86 \tparam Base
    87 base type for the operator; i.e., this operation was recorded
    88 using AD< \a Base > and computations by this routine are done using type
    89 \a Base .
    90 
    91 \param i_z
    92 variable index corresponding to the result for this operation;
     85Prototype for multiple direction forward mode unary operator with one result
     86(not used).
     87
     88\tparam Base
     89base type for the operator; i.e., this operation was recorded
     90using AD< \a Base > and computations by this routine are done using type
     91\a Base.
     92
     93\param q
     94order of the Taylor coefficients that we are computing.
     95
     96\param r
     97number of directions for Taylor coefficients that we are computing.
     98
     99\param i_z
     100variable index corresponding to the last (primary) result for this operation;
    93101i.e. the row index in \a taylor corresponding to z.
     102The auxillary result is called y has index \a i_z - 1.
    94103
    95104\param i_x
     
    97106i.e. the row index in \a taylor corresponding to x.
    98107
    99 \param nc_taylor
    100 number of colums in the matrix containing all the Taylor coefficients.
    101 
    102 \param taylor
    103 \b Input: \a taylor [ \a i_x * \a nc_taylor + 0 ]
     108\param cap_order
     109maximum number of orders that will fit in the \c taylor array.
     110
     111\par tpv
     112We use the notation
     113<code>tpv = (cap_order-1) * r + 1</code>
     114which is the number of Taylor coefficients per variable
     115
     116\param taylor
     117\b Input: If x is a variable,
     118<code>taylor [ arg[0] * tpv + 0 ]</code>,
     119is the zero order Taylor coefficient for all directions and
     120<code>taylor [ arg[0] * tpv + (k-1)*r + ell + 1 ]</code>,
     121for k = 1 , ... , q,
     122ell = 0, ..., r-1,
     123is the k-th order Taylor coefficient
     124corresponding to x and the ell-th direction.
     125\n
     126\b Input: <code>taylor [ i_z * tpv + 0 ]</code>,
     127is the zero order Taylor coefficient for all directions and
     128<code>taylor [ i_z * tpv + (k-1)*r + ell + 1 ]</code>,
     129for k = 1 , ... , q-1,
     130ell = 0, ..., r-1,
     131is the k-th order Taylor coefficient
     132corresponding to z and the ell-th direction.
     133\n
     134\b Output:
     135<code>taylor [ i_z * tpv + (q-1)*r + ell + 1]</code>,
     136ell = 0, ..., r-1,
     137is the q-th order Taylor coefficient
     138corresponding to z and the ell-th direction.
     139
     140\par Checked Assertions
     141\li NumArg(op) == 1
     142\li NumRes(op) == 2
     143\li i_x < i_z
     144\li 0 < q
     145\li q < cap_order
     146*/
     147template <class Base>
     148inline void forward_unary1_op_dir(
     149        size_t q           ,
     150        size_t r           ,
     151        size_t i_z         ,
     152        size_t i_x         ,
     153        size_t cap_order   ,
     154        Base*  taylor      )
     155{
     156        // This routine is only for documentaiton, it should not be used
     157        CPPAD_ASSERT_UNKNOWN( false );
     158}
     159
     160/*!
     161Prototype for zero order forward mode unary operator with one result (not used).
     162\tparam Base
     163base type for the operator; i.e., this operation was recorded
     164using AD< \a Base > and computations by this routine are done using type
     165\a Base .
     166
     167\param i_z
     168variable index corresponding to the result for this operation;
     169i.e. the row index in \a taylor corresponding to z.
     170
     171\param i_x
     172variable index corresponding to the argument for this operator;
     173i.e. the row index in \a taylor corresponding to x.
     174
     175\param cap_order
     176maximum number of orders that will fit in the \c taylor array.
     177
     178\param taylor
     179\b Input: \a taylor [ \a i_x * \a cap_order + 0 ]
    104180is the zero order Taylor coefficient corresponding to x.
    105181\n
    106 \b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
     182\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
    107183is the zero order Taylor coefficient corresponding to z.
    108184
     
    111187\li NumRes(op) == 1
    112188\li \a i_x < \a i_z
    113 \li \a 0 < \a nc_taylor
     189\li \a 0 < \a cap_order
    114190*/
    115191template <class Base>
     
    117193        size_t i_z         ,
    118194        size_t i_x         ,
    119         size_t nc_taylor   ,
     195        size_t cap_order   ,
    120196        Base*  taylor      )
    121197{
     
    151227i.e. the row index in \a taylor corresponding to x.
    152228
    153 \param nc_taylor
    154 number of colums in the matrix containing all the Taylor coefficients.
    155 
    156 \param taylor
    157 \a taylor [ \a i_x * \a nc_taylor + k ]
     229\param cap_order
     230maximum number of orders that will fit in the \c taylor array.
     231
     232\param taylor
     233\a taylor [ \a i_x * \a cap_order + k ]
    158234for k = 0 , ... , \a d
    159235is the k-th order Taylor coefficient corresponding to x.
    160236\n
    161 \a taylor [ \a i_z * \a nc_taylor + k ]
     237\a taylor [ \a i_z * \a cap_order + k ]
    162238for k = 0 , ... , \a d
    163239is the k-th order Taylor coefficient corresponding to z.
     
    191267\li NumRes(op) == 1
    192268\li \a i_x < \a i_z
    193 \li \a d < \a nc_taylor
     269\li \a d < \a cap_order
    194270\li \a d < \a nc_partial
    195271*/
     
    199275        size_t      i_z          ,
    200276        size_t      i_x          ,
    201         size_t      nc_taylor    ,
     277        size_t      cap_order    ,
    202278        const Base* taylor       ,
    203279        size_t      nc_partial   ,
     
    233309i.e. the row index in \a taylor corresponding to x.
    234310
    235 \param nc_taylor
    236 number of colums in the matrix containing all the Taylor coefficients.
    237 
    238 \param taylor
    239 \b Input: <code>taylor [ i_x * nc_taylor + k ]</code>
     311\param cap_order
     312maximum number of orders that will fit in the \c taylor array.
     313
     314\param taylor
     315\b Input: <code>taylor [ i_x * cap_order + k ]</code>
    240316for k = 0 , ... , q,
    241317is the k-th order Taylor coefficient corresponding to x.
    242318\n
    243 \b Input: <code>taylor [ i_z * nc_taylor + k ]</code>
     319\b Input: <code>taylor [ i_z * cap_order + k ]</code>
    244320for k = 0 , ... , p - 1,
    245321is the k-th order Taylor coefficient corresponding to z.
    246322\n
    247 \b Input: <code>taylor [ ( i_z - 1) * nc_taylor + k ]</code>
     323\b Input: <code>taylor [ ( i_z - 1) * cap_order + k ]</code>
    248324for k = 0 , ... , p-1,
    249325is the k-th order Taylor coefficient corresponding to the auxillary result y.
    250326\n
    251 \b Output: <code>taylor [ i_z * nc_taylor + k ]</code>,
     327\b Output: <code>taylor [ i_z * cap_order + k ]</code>,
    252328for k = p , ... , q,
    253329is the k-th order Taylor coefficient corresponding to z.
    254330\n
    255 \b Output: <code>taylor [ ( i_z - 1 ) * nc_taylor + k ]</code>,
     331\b Output: <code>taylor [ ( i_z - 1 ) * cap_order + k ]</code>,
    256332for k = p , ... , q,
    257333is the k-th order Taylor coefficient corresponding to
     
    262338\li NumRes(op) == 2
    263339\li i_x + 1 < i_z
    264 \li q < nc_taylor
     340\li q < cap_order
    265341\li p <= q
    266342*/
     
    271347        size_t i_z         ,
    272348        size_t i_x         ,
    273         size_t nc_taylor   ,
     349        size_t cap_order   ,
     350        Base*  taylor      )
     351{
     352        // This routine is only for documentaiton, it should not be used
     353        CPPAD_ASSERT_UNKNOWN( false );
     354}
     355
     356/*!
     357Prototype for multiple direction forward mode unary operator with two results
     358(not used).
     359
     360\tparam Base
     361base type for the operator; i.e., this operation was recorded
     362using AD< \a Base > and computations by this routine are done using type
     363\a Base.
     364
     365\param q
     366order of the Taylor coefficients that we are computing.
     367
     368\param r
     369number of directions for Taylor coefficients that we are computing.
     370
     371\param i_z
     372variable index corresponding to the last (primary) result for this operation;
     373i.e. the row index in \a taylor corresponding to z.
     374The auxillary result is called y has index \a i_z - 1.
     375
     376\param i_x
     377variable index corresponding to the argument for this operator;
     378i.e. the row index in \a taylor corresponding to x.
     379
     380\param cap_order
     381maximum number of orders that will fit in the \c taylor array.
     382
     383\par tpv
     384We use the notation
     385<code>tpv = (cap_order-1) * r + 1</code>
     386which is the number of Taylor coefficients per variable
     387
     388\param taylor
     389\b Input: <code>taylor [ i_x * tpv + 0 ]</code>
     390is the zero order Taylor coefficient for all directions and
     391<code>taylor [ i_x * tpv + (k-1)*r + ell + 1</code>
     392